@deepseek-harness-tui/dsh-tui 0.7.0 → 0.7.2

package/lib/types/screens/SessionBrowser.js

@@ -0,0 +1,437 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text, useInput, useTerminalSize } from '../ui.js';
+import { Divider } from '../components/design-system/Divider.js';
+import { HintLine } from '../components/design-system/HintLine.js';
+import { SearchBox } from '../components/SearchBox.js';
+import { SessionListRow } from '../components/sessions/SessionListRow.js';
+import { SessionPreview } from '../components/sessions/SessionPreview.js';
+import { useTerminalFocus } from '../ink/hooks/use-terminal-focus.js';
+import { isMod, isPlainReturn, modLabel } from '../utils/modifiers.js';
+import { formatProject, spreadRow, tailWidth, truncateWidth } from '../sessions/format.js';
+import { stringWidth } from '../ink/stringWidth.js';
+import { anchorTop, buildView, DEFAULT_FILTERS, moveSelection, seekSelectable, sessionAt, windowEnd, } from '../sessions/view.js';
+import { t } from '../i18n.js';
+/**
+ * Rows the layout cannot do without: the header, the search box, the hints.
+ * Everything else — the rules, the list itself — yields before these do.
+ */
+const MANDATORY_LINES = 3;
+/**
+ * The three horizontal rules, in the order they earn their row.
+ *
+ * 0 frames the header, 2 lifts the hints off the content, 1 separates the
+ * search box — and that last one is the least load-bearing, so on a terminal
+ * too short for all three it is the one that goes. Rules are decoration; a
+ * row of content, or the hint line telling the user which keys exist, is not.
+ */
+const RULE_PRIORITY = [0, 2, 1];
+/** Terminal width below which the preview replaces the list instead of joining it. */
+const SPLIT_MIN_COLUMNS = 100;
+/** A thrown value's message, for a notification that has to say something. */
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Rendered width of a hint: `HintLine` strips the `**` emphasis markers. */
+function hintWidth(text) {
+    return stringWidth(text.replace(/\*\*/gu, ''));
+}
+/**
+ * The widest hint that fits, cut only when even the shortest will not.
+ *
+ * A wrapped hint is worse than an abbreviated one in two ways: it eats rows
+ * the list needs, and — being the last region on screen — the part that falls
+ * off the bottom is its own tail, so the keys nobody can guess are exactly
+ * the ones that disappear.
+ *
+ * @param candidates - Variants from widest to narrowest.
+ * @param budget - Columns available to the row.
+ */
+function fitHint(candidates, budget) {
+    for (const candidate of candidates) {
+        if (hintWidth(candidate) <= budget)
+            return candidate;
+    }
+    return truncateWidth((candidates[candidates.length - 1] ?? '').replace(/\*\*/gu, ''), budget);
+}
+/**
+ * The session browser — `/resume` as a screen of its own.
+ *
+ * The old picker was a panel of eight titles and a timestamp, and the reason
+ * it could not be more than that was never layout: the data behind it was five
+ * fields wide. With every session now arriving classified, sized, dated and
+ * attributed, the surface that shows them can do the job a person actually
+ * came for — find one conversation among many.
+ *
+ * What that means concretely:
+ *
+ * - Search is always live. There is no mode to enter; typing filters, because
+ *   the list is the search results.
+ * - Delegated sub-agent runs are folded away by default and revealed under
+ *   their parents on demand. They are not noise to be deleted — they are the
+ *   model's own work, and it is worth being able to open one — but they are
+ *   not what "resume a conversation" means, and there are five of them for
+ *   every conversation.
+ * - Sessions that hold no conversation are never listed, only counted, with
+ *   one action to clear them.
+ * - The preview shows the end of a session, so "is this the one I was in the
+ *   middle of" is answerable without resuming it.
+ *
+ * Every one of those reads bounded data, so the screen behaves the same on a
+ * fifty-session history as on a five-session one.
+ */
+export function SessionBrowser({ channel, home, sameProject, onClose, }) {
+    const { columns, rows } = useTerminalSize();
+    const isTerminalFocused = useTerminalFocus();
+    const [sessions, setSessions] = React.useState([]);
+    const [loaded, setLoaded] = React.useState(false);
+    const [filters, setFilters] = React.useState(DEFAULT_FILTERS);
+    // The cursor is a session ID, not a row index.
+    //
+    // Rows are reordered by almost everything the browser does: a rename touches
+    // MRU and moves its row to the top, a filter rebuilds the list, a delete
+    // removes one. An index survives none of those — it keeps pointing at a
+    // POSITION, so the cursor silently lands on a different session and the next
+    // Enter or ctrl+d acts on the wrong one. Tracking identity makes "the cursor
+    // stays on the session you were looking at" true by construction instead of
+    // something every mutation has to remember to restore.
+    const [focusId, setFocusId] = React.useState(undefined);
+    // The window start is a scroll anchor, not state: it is derived from the
+    // focus every render and only ever read back to keep a stationary cursor
+    // from re-shuffling the screen. Holding it in state would mean setting
+    // state during render to resolve a layout that render already knows.
+    const topRef = React.useRef(0);
+    const [mode, setMode] = React.useState('list');
+    const [renameText, setRenameText] = React.useState('');
+    // The browser owns the whole screen, so it has to carry its own messages.
+    // `channel.notify` renders into the conversation — which is exactly what is
+    // NOT on screen right now — so a failed delete, a refused resume, or an
+    // unreadable listing would otherwise report itself to a hidden surface and
+    // look to the user like nothing happened at all.
+    const [notice, setNotice] = React.useState();
+    const [previewOpen, setPreviewOpen] = React.useState(false);
+    const [preview, setPreview] = React.useState([]);
+    const [previewLoading, setPreviewLoading] = React.useState(false);
+    // One clock per render pass: every relative time on screen must agree, and
+    // re-reading it per row would let two rows a millisecond apart round to
+    // different minutes.
+    const now = Date.now();
+    /**
+     * Say something, on screen and in the transcript.
+     *
+     * Both, deliberately: the line below the list is what the user can actually
+     * read right now, and the transcript entry is what they still have after
+     * they leave.
+     */
+    const report = React.useCallback((text, tone) => {
+        setNotice({ text, tone });
+        channel.notify(text, tone === 'error' ? { color: 'error' } : {});
+    }, [channel]);
+    // Every await below is wrapped. The adapter's own paths are total functions
+    // that degrade rather than throw, but this is the UI: a rejection escaping
+    // an event handler here becomes an unhandled rejection with the terminal in
+    // raw mode and the alternate screen active — the worst possible place to
+    // find out a promise was not caught. A failure leaves the browser standing
+    // with whatever it already had.
+    const reload = React.useCallback(async () => {
+        try {
+            setSessions(await channel.listSessions());
+        }
+        catch (error) {
+            report(t('session-list-failed', { err: message(error) }), 'error');
+        }
+        finally {
+            setLoaded(true);
+        }
+    }, [channel, report]);
+    React.useEffect(() => {
+        void reload();
+    }, [reload]);
+    const view = React.useMemo(() => buildView(sessions, filters, {
+        cwd: channel.cwd,
+        branch: channel.gitBranch,
+        currentId: channel.agentId,
+        sameProject,
+    }), [sessions, filters, channel.cwd, channel.gitBranch, channel.agentId, sameProject]);
+    // Resolve identity to a position once per render. A cursor whose session is
+    // gone — deleted, filtered out, or never there — falls to the first
+    // selectable row rather than to nothing, so the list is never unusable.
+    const focus = React.useMemo(() => {
+        const byId = view.rows.findIndex(row => row.kind === 'session' && row.session.id === focusId);
+        return byId >= 0 ? byId : Math.max(0, seekSelectable(view.rows, 0, 1));
+    }, [view.rows, focusId]);
+    const focused = sessionAt(view.rows, focus);
+    // Where the cursor is RIGHT NOW, including moves made earlier in this same
+    // tick. A held arrow key (or a paste) delivers several key events from one
+    // stdin chunk, and every one of them runs before React re-renders — so a
+    // handler that read the position from the render closure would compute all
+    // of them from the same starting row and keep only the last, silently
+    // dropping every move but one.
+    const focusRef = React.useRef(focus);
+    focusRef.current = focus;
+    /** Move the cursor by rows, then store the session it landed on. */
+    const step = (by, times = 1) => {
+        let next = focusRef.current;
+        for (let taken = 0; taken < times; taken++)
+            next = moveSelection(view.rows, next, by);
+        focusRef.current = next;
+        const landed = sessionAt(view.rows, next);
+        if (landed !== undefined)
+            setFocusId(landed.id);
+    };
+    // Preview follows the cursor. Keyed on the id so arrowing past a row does
+    // not refetch the one it came from, and guarded on unmount so a slow read
+    // landing after the cursor moved cannot overwrite a newer preview.
+    React.useEffect(() => {
+        if (!previewOpen || focused === undefined)
+            return;
+        let live = true;
+        setPreviewLoading(true);
+        void channel
+            .previewSession(focused.id)
+            .then(entries => (live ? entries : undefined))
+            .catch(() => (live ? [] : undefined))
+            .then((entries) => {
+            if (entries === undefined)
+                return;
+            setPreview(entries);
+            setPreviewLoading(false);
+        });
+        return () => {
+            live = false;
+        };
+    }, [channel, previewOpen, focused?.id]);
+    // Wide terminals put the preview beside the list; narrow ones put it in the
+    // list's place. Tab must always visibly do something — a preview that
+    // silently declines to appear below some width is a dead key.
+    const splitPreview = previewOpen && columns >= SPLIT_MIN_COLUMNS;
+    const soloPreview = previewOpen && columns < SPLIT_MIN_COLUMNS;
+    const previewWidth = splitPreview ? Math.min(56, Math.floor(columns * 0.42)) : columns;
+    const listWidth = Math.max(20, columns - (splitPreview ? previewWidth : 0));
+    // Height is distributed, never assumed. Mandatory rows first, then a row
+    // for each region the current state actually needs, then the rules while
+    // rows remain, and the list gets what is left — which may be nothing.
+    //
+    // The arithmetic below is the whole vertical layout: the regions sum to
+    // exactly `rows` at every height down to MANDATORY_LINES. Anything that
+    // assumed a fixed chrome would overflow on a short terminal, and the row
+    // that falls off the bottom is always the last one — the hints.
+    const extraLines = (mode === 'list' ? 0 : 1) + (notice === undefined ? 0 : 1);
+    const ruleBudget = Math.max(0, Math.min(RULE_PRIORITY.length, rows - MANDATORY_LINES - extraLines));
+    const rules = new Set(RULE_PRIORITY.slice(0, ruleBudget));
+    const listHeight = Math.max(0, rows - MANDATORY_LINES - extraLines - rules.size);
+    const windowTop = anchorTop(view.rows, focus, listHeight, topRef.current);
+    topRef.current = windowTop;
+    const visible = view.rows.slice(windowTop, windowEnd(view.rows, windowTop, listHeight));
+    /**
+     * Change the view.
+     *
+     * Takes a function of the CURRENT filters rather than a ready-made patch,
+     * for the same reason the cursor keeps a ref: several key events can be
+     * handled before React re-renders, and a patch built from the render
+     * closure would compute each of them from the same starting filters — two
+     * toggles in one chunk cancelling to one, or typed characters overwriting
+     * each other instead of accumulating.
+     */
+    const applyFilters = (update) => {
+        setFilters(current => ({ ...current, ...update(current) }));
+        topRef.current = 0;
+    };
+    /** Run one mutation, report it, and re-list — reporting a failure either way. */
+    const mutate = (action, done, failed) => {
+        void (async () => {
+            let ok = false;
+            let reason;
+            try {
+                ok = await action();
+            }
+            catch (error) {
+                reason = message(error);
+            }
+            report(ok ? done : reason === undefined ? failed : `${failed} · ${reason}`, ok ? 'info' : 'error');
+            await reload();
+        })();
+    };
+    const runDelete = (target) => mutate(() => channel.deleteSession(target.id), t('resume-deleted', { name: target.title.text }), t('resume-delete-failed', { name: target.title.text }));
+    const runRename = (target, title) => mutate(() => channel.renameSessionTo(target.id, title), t('rename-done', { title }), t('resume-rename-failed', { name: target.title.text }));
+    const runClean = () => {
+        // Snapshot the ids before any await: the view is rebuilt by the reload
+        // below, and deleting from a list that moved under us would be a
+        // destructive action aimed at whatever happens to be there now.
+        const ids = [...view.emptyIds];
+        void (async () => {
+            let removed = 0;
+            for (const id of ids) {
+                try {
+                    if (await channel.deleteSession(id))
+                        removed += 1;
+                }
+                catch {
+                    // One unremovable log must not abandon the rest of the sweep.
+                }
+            }
+            report(t('session-cleaned', { n: removed }), 'info');
+            await reload();
+        })();
+    };
+    useInput((input, key) => {
+        // A notice describes what the LAST action did; the next keystroke makes it
+        // stale, so it goes as soon as the user acts again.
+        if (notice !== undefined)
+            setNotice(undefined);
+        if (mode === 'confirm-delete') {
+            if (isPlainReturn(key)) {
+                setMode('list');
+                if (focused !== undefined)
+                    runDelete(focused);
+            }
+            else if (key.escape) {
+                setMode('list');
+            }
+            return;
+        }
+        if (mode === 'confirm-clean') {
+            if (isPlainReturn(key)) {
+                setMode('list');
+                runClean();
+            }
+            else if (key.escape) {
+                setMode('list');
+            }
+            return;
+        }
+        if (mode === 'rename') {
+            if (isPlainReturn(key)) {
+                setMode('list');
+                const title = renameText.trim();
+                if (focused !== undefined && title.length > 0)
+                    runRename(focused, title);
+            }
+            else if (key.escape) {
+                setMode('list');
+            }
+            else if (key.backspace || key.delete) {
+                setRenameText(text => text.slice(0, -1));
+            }
+            else if (!isMod(key) && !key.meta && input) {
+                setRenameText(text => text + input.replace(/[\r\n]+/g, ' '));
+            }
+            return;
+        }
+        if (key.upArrow) {
+            step(-1);
+        }
+        else if (key.downArrow) {
+            step(1);
+        }
+        else if (key.pageUp || key.pageDown) {
+            // A page is "as many rows as the window holds", taken as repeated single
+            // steps so it lands on a selectable row like every other move.
+            step(key.pageDown ? 1 : -1, Math.max(1, Math.floor(listHeight / 2)));
+        }
+        else if (isPlainReturn(key)) {
+            if (focused === undefined)
+                return;
+            const target = focused;
+            // The screen closes only once the resume actually happened. Closing
+            // first and letting a refusal fall through to a notification would send
+            // that explanation to the conversation the user is not looking at, and
+            // leave them staring at an unchanged transcript wondering what Enter
+            // did. `resumeTo` reports its own reasons; this only has to stay put.
+            void channel
+                .resumeTo(target.id)
+                .then((ok) => {
+                if (ok) {
+                    channel.notify(t('resume-resumed'));
+                    onClose();
+                }
+                else {
+                    setNotice({ text: t('session-resume-refused'), tone: 'error' });
+                }
+            })
+                .catch((error) => {
+                setNotice({ text: t('session-resume-failed', { err: message(error) }), tone: 'error' });
+            });
+        }
+        else if (key.escape) {
+            // Esc backs out one layer at a time: a live query first, the screen
+            // second. Closing on the first Esc would discard a search the user is
+            // still refining.
+            if (filters.query.length > 0)
+                applyFilters(() => ({ query: '' }));
+            else
+                onClose();
+        }
+        else if (key.tab) {
+            setPreviewOpen(open => !open);
+        }
+        else if (isMod(key) && input === 'a') {
+            applyFilters(current => ({ allProjects: !current.allProjects }));
+        }
+        else if (isMod(key) && input === 'b') {
+            applyFilters(current => ({ branchOnly: !current.branchOnly }));
+        }
+        else if (isMod(key) && input === 's') {
+            applyFilters(current => ({ showSubagents: !current.showSubagents }));
+        }
+        else if (isMod(key) && input === 'r' && focused !== undefined) {
+            setRenameText(focused.title.text);
+            setMode('rename');
+        }
+        else if (isMod(key) && input === 'd' && focused !== undefined) {
+            setMode('confirm-delete');
+        }
+        else if (isMod(key) && input === 'x' && view.emptyCount > 0) {
+            setMode('confirm-clean');
+        }
+        else if (key.backspace || key.delete) {
+            applyFilters(current => ({ query: current.query.slice(0, -1) }));
+        }
+        else if (!isMod(key) && !key.meta && !key.super && input && !key.return) {
+            // Only real characters reach the query. Anything else the terminal
+            // delivers — an unbound control byte, a chord this screen does not
+            // claim, the newlines inside a paste — would otherwise be typed into
+            // the search box invisibly, leaving a filter that matches nothing for
+            // no reason the user can see.
+            const typed = input.replace(/\p{Cc}/gu, '');
+            if (typed.length > 0)
+                applyFilters(current => ({ query: current.query + typed }));
+        }
+    });
+    const counts = [];
+    counts.push(t('session-count-shown', { n: view.shown }));
+    if (view.hiddenSubagents > 0)
+        counts.push(t('session-count-subagents', { n: view.hiddenSubagents }));
+    if (view.emptyCount > 0)
+        counts.push(t('session-count-empty', { n: view.emptyCount }));
+    // The header is laid out as one pre-measured row rather than a flex row: at
+    // an exact fit, flex truncation eats a character and the row reflows, which
+    // pushes every region below it down by one. `spreadRow` owns the column
+    // arithmetic and the regression pins its invariant directly.
+    const heading = ` ${t('resume-title')}`;
+    const header = spreadRow(heading, counts.join(' · '), Math.max(0, columns - 1));
+    const scope = filters.allProjects
+        ? t('session-scope-all')
+        : formatProject(channel.cwd, home);
+    // One budget for every full-width single-line region: the search box, the
+    // confirmations, the rename editor, the notice. Each of them carries text
+    // whose length nobody controls — a session title, a filesystem path, an
+    // error message — and each of them sits between the list and the hints,
+    // where one wrapped row costs the list a line and can push the hints off
+    // the bottom of the screen.
+    const inputBudget = Math.max(0, columns - 2);
+    const hint = mode === 'confirm-delete' || mode === 'confirm-clean'
+        ? fitHint([t('resume-hint-delete')], inputBudget)
+        : mode === 'rename'
+            ? fitHint([t('resume-hint-rename')], inputBudget)
+            : fitHint([
+                t('session-hint-list', {
+                    mod: modLabel,
+                    projects: filters.allProjects ? t('session-toggle-on') : t('session-toggle-off'),
+                    runs: filters.showSubagents ? t('session-toggle-on') : t('session-toggle-off'),
+                }),
+                t('session-hint-list-mid', { mod: modLabel }),
+                t('session-hint-list-short'),
+            ], inputBudget);
+    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [_jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { color: "remember", bold: true, children: header.left }), _jsx(Text, { dimColor: true, children: `${' '.repeat(header.gap)}${header.right}` })] }), rules.has(0) && (_jsx(Box, { flexShrink: 0, children: _jsx(Divider, { width: columns }) })), _jsx(Box, { flexShrink: 0, children: _jsx(SearchBox, { query: tailWidth(filters.query, inputBudget), isFocused: mode === 'list', isTerminalFocused: isTerminalFocused, placeholder: truncateWidth(t('session-search-placeholder', { scope }), inputBudget), borderless: true }) }), rules.has(1) && (_jsx(Box, { flexShrink: 0, children: _jsx(Divider, { width: columns }) })), _jsxs(Box, { flexGrow: 1, flexShrink: 1, children: [!soloPreview && (_jsxs(Box, { flexDirection: "column", width: listWidth, height: listHeight, flexShrink: 0, children: [!loaded && (_jsx(Text, { dimColor: true, italic: true, children: ` ${truncateWidth(t('session-loading'), listWidth - 2)}` })), loaded && view.rows.length === 0 && (_jsx(Text, { dimColor: true, italic: true, children: ` ${truncateWidth(t('resume-none-in-cwd'), listWidth - 2)}` })), visible.map((row, index) => row.kind === 'project' ? (_jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { color: "planMode", children: truncateWidth(` ${formatProject(row.project, home)}`, listWidth - 6) }), _jsx(Text, { dimColor: true, children: `  ${row.count}` })] }, `project:${row.project}:${index}`)) : (_jsx(SessionListRow, { session: row.session, width: listWidth, depth: row.depth, focused: windowTop + index === focus, now: now }, row.session.id)))] })), (splitPreview || soloPreview) && focused !== undefined && (_jsx(SessionPreview, { session: focused, entries: preview, loading: previewLoading, width: previewWidth, height: listHeight, home: home, now: now }))] }), notice !== undefined && (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: notice.tone === 'error' ? 'error' : 'success', children: ` ${truncateWidth(notice.text, Math.max(0, columns - 2))}` }) })), mode === 'confirm-delete' && focused !== undefined && (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: "error", children: ` ${truncateWidth(t('resume-delete-confirm', { name: focused.title.text }), inputBudget)}` }) })), mode === 'confirm-clean' && (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: "warning", children: ` ${truncateWidth(t('session-clean-confirm', { n: view.emptyCount }), inputBudget)}` }) })), mode === 'rename' && (_jsx(Box, { flexShrink: 0, children: _jsx(SearchBox, { query: tailWidth(renameText, inputBudget), isFocused: true, isTerminalFocused: isTerminalFocused, placeholder: truncateWidth(t('resume-rename-placeholder'), inputBudget), prefix: "\u270E", borderless: true }) })), rules.has(2) && (_jsx(Box, { flexShrink: 0, children: _jsx(Divider, { width: columns }) })), _jsx(Box, { flexShrink: 0, children: _jsx(Text, { dimColor: true, italic: true, children: _jsx(HintLine, { text: hint }) }) })] }));
+}

package/lib/types/sessionHistory.d.ts

@@ -1,11 +1,3 @@
-/** One persisted session as the `/resume` picker lists it. */
-export interface SessionRecord {
-    id: string;
-    title: string;
-    cwd: string;
-    createdAt: number;
-    updatedAt: number;
-}
 /**
  * Store the session to resume and report the launcher invocation.
  * Dual-writes the legacy path for pre-rename launchers (see header).

package/lib/types/sessionHistory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessionHistory.d.ts","sourceRoot":"","sources":["../../src/sessionHistory.ts"],"names":[],"mappings":"AAoBA,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAWD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CASzD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAUrD;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUrD"}
+{"version":3,"file":"sessionHistory.d.ts","sourceRoot":"","sources":["../../src/sessionHistory.ts"],"names":[],"mappings":"AA6BA;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CASzD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAUrD;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUrD"}

package/lib/types/sessions/format.d.ts

@@ -0,0 +1,117 @@
+import type { SessionKind, TitleSource } from '../dsh-adapter/sessions/index.js';
+import type { Theme } from '../theme.js';
+/**
+ * Truncate to a terminal DISPLAY width, CJK-aware (a wide character costs two
+ * columns).
+ *
+ * Used wherever the cut has to be exact: Ink's own `wrap="truncate"` appends
+ * its ellipsis as soon as content is as wide as its box rather than wider,
+ * which silently eats the last character of a row laid out at its natural
+ * width — and a row that then reflows pushes every row below it down.
+ *
+ * @param text - Plain text, no ANSI.
+ * @param maxWidth - Column budget, ellipsis included.
+ * @returns `text` when it fits, otherwise a cut ending in `…`.
+ */
+export declare function truncateWidth(text: string, maxWidth: number): string;
+/** A row laid out as `left`, blank columns, then `right`. */
+export interface SpreadRow {
+    /** The left-hand segment, cut only if it alone exceeds the row. */
+    readonly left: string;
+    /** Blank columns between the two segments; at least one. */
+    readonly gap: number;
+    /** The right-hand segment, cut to whatever room the left one left. */
+    readonly right: string;
+}
+/**
+ * Lay out one row with its two ends pushed apart.
+ *
+ * Measured in COLUMNS, which is the whole reason this is a function rather
+ * than three expressions at the call site. Every string it receives is
+ * localized, and in Chinese a character is two columns wide — arithmetic on
+ * `.length` overstates the gap by the width of the text itself, so the row
+ * overflows and the terminal either wraps it (shifting every region below it
+ * down a line) or clips it (silently eating the right-hand segment). Both
+ * failures are invisible to an English-only test.
+ *
+ * The invariant, which the regression checks exhaustively: the assembled row
+ * is never wider than `columns`.
+ *
+ * @param left - Text pinned to the start of the row.
+ * @param right - Text pinned to the end, truncated when it will not fit.
+ * @param columns - Total width available.
+ */
+export declare function spreadRow(left: string, right: string, columns: number): SpreadRow;
+/**
+ * Keep the END of a string within a display width, CJK-aware.
+ *
+ * What a single-line editor does: the caret lives at the end, so that is the
+ * part worth showing. Used where text the user is typing has to stay on ONE
+ * row — a wrapped input row steals a line from the list and can push the row
+ * below it off the bottom of the screen.
+ *
+ * @param text - Plain text, no ANSI.
+ * @param maxWidth - Column budget, leading ellipsis included.
+ * @returns `text` when it fits, otherwise `…` followed by its tail.
+ */
+export declare function tailWidth(text: string, maxWidth: number): string;
+/**
+ * Elapsed time as a person would say it: `just now`, `9 hours ago`, and an
+ * absolute date once "ago" stops being useful.
+ *
+ * The cut to an absolute date is at a week rather than a month because that is
+ * roughly where a relative offset stops locating anything — "23 days ago" is a
+ * number to be decoded, `Mar 3` is a memory.
+ *
+ * @param at - Epoch ms of the moment being described.
+ * @param now - Epoch ms of the present, injectable so the formatter is a pure
+ *   function and its regression does not depend on a clock.
+ */
+export declare function formatWhen(at: number, now: number): string;
+/**
+ * Byte size at the precision the number is worth: `812 B`, `142.9 KB`,
+ * `4.2 MB`. One decimal from kilobytes up, because the digit distinguishes a
+ * short exchange from a long one and a second would not.
+ */
+export declare function formatBytes(bytes: number | undefined): string | undefined;
+/**
+ * Marker for a row's kind, or undefined for an ordinary conversation.
+ *
+ * Only the exceptional kinds are marked. A badge on every row would cost a
+ * column of width and teach nothing — what a reader needs to see at a glance
+ * is which rows are *not* the thing they came for.
+ */
+export declare function kindMark(kind: SessionKind): {
+    glyph: string;
+    color: keyof Theme;
+} | undefined;
+/**
+ * Wrap to a display width, CJK-aware.
+ *
+ * Greedy, breaking on a space when one is available in the line just filled
+ * and mid-character when it is not — which is the correct behaviour for CJK,
+ * where there are no spaces to break on and a word-only wrapper would emit one
+ * enormous unbreakable line. Newlines in the input are honoured.
+ *
+ * @param text - Plain text, no ANSI.
+ * @param width - Column budget per line.
+ * @returns The wrapped lines, never empty for non-empty input.
+ */
+export declare function wrapWidth(text: string, width: number): string[];
+/** Human name of a session kind, for the preview pane's header. */
+export declare function kindLabel(kind: SessionKind): string;
+/**
+ * Colour for a title, by how much is actually known about it.
+ *
+ * A title the user chose is stated plainly; one a model generated reads the
+ * same, because it is a real title; a first-prompt excerpt is dimmer, because
+ * it is the session speaking rather than a name; a directory basename is
+ * dimmest of all, because it says only "nothing here was readable".
+ */
+export declare function titleColor(source: TitleSource, focused: boolean): keyof Theme;
+/**
+ * Project label for a group header: the working directory, with `$HOME`
+ * collapsed to `~` so the eye lands on the part that differs.
+ */
+export declare function formatProject(cwd: string, home: string): string;
+//# sourceMappingURL=format.d.ts.map

package/lib/types/sessions/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/sessions/format.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAChF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAYpE;AAED,6DAA6D;AAC7D,MAAM,WAAW,SAAS;IACxB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,4DAA4D;IAC5D,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAajF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAchE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAc1D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAKzE;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,KAAK,CAAA;CAAE,GAAG,SAAS,CAI7F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA4B/D;AAED,mEAAmE;AACnE,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAInD;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,KAAK,CAK7E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ/D"}