@north-light/api 0.3.579 → 0.3.587

package/dist/clients/dashboard/render.js

@@ -0,0 +1,148 @@
+// render.ts — pure frame rendering for the dashboard: lines in, one repaint string out.
+import { assemble, clip } from '../../core/tui/draw.js';
+import { resolveNodeVisual } from '../../core/canvas/status-glyph.js';
+import { BOLD, DIM, ESC, RESET, REVERSE } from '../../core/canvas/nav-render.js';
+import { SECTION_TITLE } from './model.js';
+const CURSOR_BG = `${ESC}48;5;236m`;
+const HELP_ROWS = [
+    ['j k ↑ ↓', 'move'],
+    ['g G', 'first / last'],
+    ['l → / h ←', 'show / hide children'],
+    ['Enter', 'open (the ask first, when one is waiting)'],
+    ['p', 'pin or unpin'],
+    ['R', 'rename'],
+    ['x', 'close (asks first when something is running)'],
+    ['P', 'this profile / all profiles'],
+    ['n', 'new conversation: type, Tab picks a directory, Enter starts it'],
+    ['Esc', 'leave the input'],
+    ['?', 'this help'],
+];
+/** Height of the list area: rows minus title, input line and footer. */
+export function listHeight(rows) {
+    return Math.max(1, Math.max(8, rows) - 3);
+}
+function renderHelp(size) {
+    const width = Math.max(20, size.cols) - 1;
+    const out = [`${BOLD}Dashboard — keys${RESET}`, ''];
+    for (const [keys, desc] of HELP_ROWS)
+        out.push(clip(`  ${BOLD}${keys.padEnd(12)}${RESET}  ${DIM}${desc}${RESET}`, width + 20));
+    out.push('', `${DIM}  any key closes${RESET}`);
+    while (out.length < Math.max(8, size.rows) - 1)
+        out.push('');
+    return `${ESC}H${out.map((l) => `${l}${ESC}K`).join('\r\n')}${ESC}J`;
+}
+function rootSpans(line, pinned, width, caps) {
+    const r = line.row;
+    const visual = resolveNodeVisual(r.status, { streaming: r.running_count > 0 });
+    const text = r.state_line ?? r.goal ?? '';
+    const right = [];
+    if (r.running_count > 0)
+        right.push({ text: `⟳ ${r.running_count}`, style: { fg: '92' } }, { text: '  ' });
+    if (r.asks > 0)
+        right.push({ text: `? ${r.asks}`, style: { fg: '93', bold: true } }, { text: '  ' });
+    if (r.fault !== null)
+        right.push({ text: '⚠', style: { fg: '33', bold: true } }, { text: ' ' });
+    const rightW = right.reduce((n, s) => n + s.text.length, 0);
+    const lead = `${line.expanded ? '▾' : '▸'} `;
+    const nameW = Math.min(r.name.length, Math.max(10, Math.floor(width / 3)));
+    const name = clip(r.name, nameW);
+    const textW = Math.max(0, width - rightW - lead.length - 2 - name.length - 2 - (pinned ? 2 : 0) - 1);
+    const left = [
+        { text: ' ' },
+        { text: visual.glyph, style: { fg: visual.color } },
+        { text: ' ' },
+        { text: lead, style: { dim: true } },
+        ...(pinned ? [{ text: '★ ', style: { fg: '33' } }] : []),
+        { text: name, style: { bold: true } },
+        { text: '  ' },
+        { text: clip(text.replace(/\s+/g, ' '), textW), style: { dim: true } },
+    ];
+    void caps;
+    return { left, right };
+}
+function childSpans(line, width) {
+    const c = line.child;
+    const visual = resolveNodeVisual(c.status, { streaming: c.streaming });
+    const right = [];
+    if (c.streaming)
+        right.push({ text: '⟳', style: { fg: '92' } }, { text: '  ' });
+    if (c.asks > 0)
+        right.push({ text: `? ${c.asks}`, style: { fg: '93', bold: true } }, { text: '  ' });
+    if (c.fault !== null)
+        right.push({ text: '⚠', style: { fg: '33', bold: true } }, { text: ' ' });
+    const left = [
+        { text: '     ' },
+        { text: visual.glyph, style: { fg: visual.color } },
+        { text: ' ' },
+        { text: clip(c.name, Math.max(10, width - 12)) },
+    ];
+    return { left, right };
+}
+function spansWidth(spans) {
+    return spans.reduce((n, s) => n + s.text.length, 0);
+}
+export function renderDashboard(state, size, caps) {
+    if (state.help)
+        return renderHelp(size);
+    const cols = Math.max(20, size.cols);
+    const rows = Math.max(8, size.rows);
+    const width = cols - 1;
+    const out = [];
+    const scopeText = state.scope === 'all' ? 'all profiles' : state.profileLabel;
+    const rootCount = state.lines.filter((l) => l.kind === 'root').length;
+    out.push(`${BOLD}Dashboard${RESET} ${DIM}— ${scopeText} · ${rootCount} live${RESET}`);
+    const height = listHeight(rows) - 1;
+    const body = [];
+    if (state.lines.length === 0) {
+        body.push(`${DIM}  ${state.loaded ? 'no live conversations — press n to start one' : 'loading…'}${RESET}`);
+    }
+    for (let i = state.scroll; i < Math.min(state.lines.length, state.scroll + height); i++) {
+        const line = state.lines[i];
+        if (line.kind === 'heading') {
+            body.push(`${BOLD}${clip(`${SECTION_TITLE[line.section]} (${line.count})`, width)}${RESET}`);
+            continue;
+        }
+        const isCursor = i === state.cursor;
+        const parts = line.kind === 'root'
+            ? rootSpans(line, state.pinned.has(line.id), width, caps)
+            : childSpans(line, width);
+        const lineBase = isCursor ? (caps.color256 ? CURSOR_BG : REVERSE) : '';
+        const pad = Math.max(1, width - spansWidth(parts.left) - spansWidth(parts.right));
+        const spans = spansWidth(parts.left) + spansWidth(parts.right) + 1 > width
+            ? parts.left
+            : [...parts.left, { text: ' '.repeat(pad) }, ...parts.right];
+        body.push(assemble(spans, width, caps.color, lineBase, isCursor));
+    }
+    while (body.length < height)
+        body.push('');
+    out.push(...body);
+    // input line (directory chip beside it)
+    const chip = `[${state.chipDir}]`;
+    if (state.rename !== null) {
+        out.push(`${ESC}36mrename ▸${RESET} ${state.rename}▎`);
+    }
+    else if (state.inputFocused) {
+        out.push(clip(`${ESC}36mnew ▸${RESET} ${state.inputText}▎  ${DIM}${chip}${RESET}`, width + 24));
+    }
+    else {
+        const prompt = state.inputText === '' ? 'n  start a conversation' : state.inputText;
+        out.push(clip(`${DIM}▸ ${prompt}  ${chip}${RESET}`, width + 12));
+    }
+    // footer
+    if (state.confirmName !== null) {
+        out.push(`${BOLD}${ESC}93m${clip(`⚠ ${state.confirmName} is running — close it (and its subtree) anyway?  y / n`, width)}${RESET}`);
+    }
+    else if (state.notice !== null) {
+        out.push(`${BOLD}${clip(state.opening ? `opening… ${state.notice}` : state.notice, width)}${RESET}`);
+    }
+    else if (state.opening) {
+        out.push(`${BOLD}opening…${RESET}`);
+    }
+    else if (state.inputFocused || state.rename !== null) {
+        out.push(`${DIM}${clip('⏎ confirm  Esc leave  Tab directory', width)}${RESET}`);
+    }
+    else {
+        out.push(`${DIM}${clip('↑↓ move  ⏎ open  →/← children  n new  p pin  R rename  x close  P profiles  ? help', width)}${RESET}`);
+    }
+    return `${ESC}H${out.map((l) => `${l}${ESC}K`).join('\r\n')}${ESC}J`;
+}

package/dist/clients/inbox/controller.d.ts

@@ -0,0 +1,174 @@
+import type { Key } from './tui/keys.js';
+import type { SurfaceHost } from '../surfaces/host.js';
+import type { InboxRow } from './dto-adapt.js';
+/** The attached node's profile, when it has one. The list opens filtered to
+ *  this profile's nodes and uppercase P toggles that off for this open inbox. */
+export interface InboxProfileScope {
+    /** Stable profile id the membership set was fetched for. */
+    id: string;
+    /** Display name for the heading; never used to decide membership. */
+    label: string;
+    /** Node ids in that profile, re-read on every rescan. */
+    members: () => ReadonlySet<string>;
+}
+export interface InboxControllerOptions {
+    host: SurfaceHost;
+    /** Called whenever the rendered frame may have changed. */
+    onDirty: () => void;
+    /** Called after the controller has finished closing itself. */
+    onClosed: () => void;
+    cols?: number;
+    rows?: number;
+    scan?: () => Promise<InboxRow[]>;
+    /** Replaces the default rescan after inbox activity. */
+    onInboxActivity?: () => void;
+    /** Ticket dir to seat the selection on at construction, when present. */
+    initialSelection?: string;
+    profile?: InboxProfileScope;
+}
+type Screen = 'list' | 'detail';
+/** Host-agnostic model for scanning, stable selection, claims, and rendering. */
+export declare class InboxController {
+    private readonly options;
+    private readonly host;
+    private readonly scan;
+    /** Every row the daemon's inbox leaves eligible. This, never the
+     *  profile-filtered list, decides whether a ticket has settled. */
+    private items;
+    /** The eligible rows the current filter shows. */
+    private visible;
+    private readonly profile;
+    private filter;
+    /** Ticket dir the caller asked to open on, until the first scan can seat it. */
+    private pendingSeat;
+    private selectedDir;
+    /** Position hint into `visible`; the highlight itself is derived from
+     *  `selectedDir`, which an open detail may hold on a filtered-out ticket. */
+    private selectedIndex;
+    private screen;
+    private adapter;
+    private reviewAdapter;
+    private focusingSource;
+    private claim;
+    private submittingDir;
+    private cancelConfirmation;
+    private cols;
+    private rows;
+    private status;
+    /** Set while the latest refresh failed, so the list is known incomplete. */
+    private refreshError;
+    private watchers;
+    private selectedWatcher;
+    private heartbeat;
+    private started;
+    private closed;
+    /** The selected page's projection, kept across frames because fetching it is
+     *  a round trip. `view` is held so a width change re-wraps without one. */
+    private preview;
+    /** A preview read that failed, so the panel says so instead of staying blank. */
+    private previewFailed;
+    /** In-flight preview fetch, keyed by dir: one request per selection at a time. */
+    private previewFetching;
+    /** Set by `invalidate`: the held preview may no longer be the current revision. */
+    private previewStale;
+    /** The revision the open detail was loaded from, so a replacement published
+     *  while the reader has the page open reloads it. */
+    private openRevision;
+    constructor(options: InboxControllerOptions);
+    snapshot(): {
+        items: InboxRow[];
+        selectedDir?: string;
+        screen: Screen;
+        inputBuffer?: string;
+    };
+    rescan(): Promise<void>;
+    /** Apply the active filter to the eligible list. A ticket belongs to the
+     *  profile exactly when its requesting node is one of that profile's nodes;
+     *  an absent or unknown requester is reachable under all profiles only. */
+    private recomputeVisible;
+    /** Put the highlight back on a visible row after the list or the filter
+     *  changed under it, keeping the same list position when the selected ticket
+     *  is gone. An open detail holds its own ticket instead, filtered out or not. */
+    private reseatSelection;
+    /** Index of the highlighted row, or -1 while an open detail holds a ticket
+     *  the filter hides — no other row stands in for it. */
+    private highlightIndex;
+    /** The highlighted ticket, absent when no visible row is highlighted. */
+    private currentRow;
+    private scopeHeading;
+    /** Record how a surface refresh ended. A failure names itself while the last
+     *  complete list stays on screen — never an empty profile or a silent
+     *  widening — and the next successful refresh takes that notice away. */
+    refreshOutcome(error?: string): void;
+    start(): void;
+    /** Inbox activity is the one signal a replacement always emits, and it is
+     *  emitted after the new revision is selected — so an open page reloads here
+     *  rather than from a file watch that cannot see a directory swap. */
+    invalidate(): Promise<void>;
+    resize(cols: number, rows: number): void;
+    render(): string[];
+    handleKey(input: string, key: Key): void;
+    /** Swap between this profile's tickets and every eligible ticket. The mode
+     *  lives only until this inbox closes; the next open starts filtered again. */
+    private toggleProfileFilter;
+    /** Settle the selected ticket from the list with what crouter already put on
+     *  its summary — the agent's recommended option, or a notice's empty map. A
+     *  row without a fast action says so rather than opening the page: the key
+     *  means one thing, and the page is what Enter is for. */
+    private sendFastAction;
+    /** A review and a page are two different durable records; the inbox dismisses
+     *  whichever one the selected row actually is. */
+    private cancelFromInbox;
+    activate(): Promise<void>;
+    /** A review opens in its own tmux window, which tmux selects at once, so
+     *  the inbox left behind in this pane has nothing more to do: it closes,
+     *  and returning to this window lands on the conversation beneath it. The
+     *  inbox stays up only when the window could not be opened, so its notice
+     *  is read where the person is looking. */
+    private activateReview;
+    /** Seat the selection on a ticket dir, when present in the current list. */
+    selectDir(dir: string): void;
+    /** Seat the selection on an eligible ticket, widening to all profiles when
+     *  the profile filter alone is what hides it — a caller that names a ticket
+     *  is promised that ticket, never a neighbouring one. */
+    private seatOn;
+    /** Re-read the open page and reload it only when its revision actually moved. */
+    reloadSelectedPage(): Promise<void>;
+    close(): void;
+    private complete;
+    /** Edit the active buffer while the host releases the terminal to $EDITOR. */
+    private editActivePageInput;
+    private leaveDetail;
+    private select;
+    private detailSize;
+    private detailLines;
+    private focusAvailable;
+    /** Ask the host to bring the requesting node's viewer into view — the
+     *  conversation that raised this ask. */
+    private focusSelectedSource;
+    /** What the selected page actually says. Rendering is synchronous and the
+     *  page is a round trip, so the projection is held and a miss schedules the
+     *  fetch, marking the frame dirty when it lands. A width change re-wraps the
+     *  held projection without another read. */
+    private pagePreviewBody;
+    /** One in-flight preview read at a time. A revision that did not move keeps
+     *  the held projection, so activity on an unrelated ticket costs no re-wrap. */
+    private schedulePreview;
+    /** The request record is the settlement authority: a settled page publishes
+     *  no file, so a claim would still succeed on its directory. An unreachable
+     *  daemon reads as "not known to be settled" — the settle attempt that
+     *  follows is the one that fails loudly. */
+    private requestOrNull;
+    /** The read-only preview beside the list. It shows the page's own content,
+     *  because `s` settles the selected ticket from here without ever opening
+     *  it — a reader must not answer something they were never shown. */
+    private passiveDetailLines;
+    private withStatus;
+    private markDirty;
+    private watchRoots;
+    /** The request directory still carries the claim and progress files other
+     *  inboxes write. Its page content lives in the daemon-selected revision,
+     *  which `invalidate` re-reads over the API. */
+    private watchSelected;
+}
+export {};