@softov/ahpc 0.1.0

package/dist/src/view/creature.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A small drawn thing, above the invitation to say something.
+ *
+ * An empty screen is the one place a client can afford a figure, and a
+ * different one each time is the difference between an application that has a
+ * mascot and one that has a habit.
+ *
+ * The drawings moved to [`bood/`](./bood/index.ts) - one creature per file,
+ * registered by name, in three sizes and five moods. This file is the door
+ * they were already behind, and it stays: `<Creature mood="happy" />` on the
+ * empty screen means what it always meant.
+ *
+ * Two rules, and both of them came from watching art break in a terminal.
+ *
+ * Plain ASCII, every character. Not one glyph is one whose width the terminal
+ * gets to decide - box drawing and the half-block set are the ones that get
+ * eaten by a CJK font setting, and art that is one cell wider on somebody
+ * else's machine does not look narrow, it looks broken. `registerCreature`
+ * checks this rather than trusting it.
+ *
+ * No shared frame, no shared face window, no shared size at full size. The
+ * figures run from seven cells wide to seventeen and the outline *is* the
+ * animal. A creature that fits a template is a template wearing a hat - which
+ * is exactly what `block` and `inline` are, and why they are drawn separately
+ * instead of being the big one shrunk.
+ */
+import type { Mood } from './bood/index.js';
+import type { Activity } from '../ahp/status.js';
+export { BoodSprite, Creature, MOODS, FORMS, creatureFrames, creatureMotion, creatureSize, drawCreature, livelyNames, } from './bood/index.js';
+export type { CreatureProps, Form, Mood } from './bood/index.js';
+/**
+ * What the figure is doing, from what the session is doing.
+ *
+ * The moods were always meant to be read off real state rather than chosen, and
+ * this is the only place the two vocabularies meet: five drawn moods, four
+ * activities the protocol actually reports. `sad` has no source and is drawn
+ * anyway, because a mood with nothing to trigger it is a drawing waiting for a
+ * state rather than a bug - and inventing a session state to justify it would
+ * be the tail wagging the dog.
+ *
+ * `input` is thinking rather than happy: a session waiting on a person has
+ * stopped, and the figure standing still and looking at you is the reading
+ * that matches the status row above it.
+ */
+export declare function moodOf(activity: Activity): Mood;
+/**
+ * Say which row this component starts at, so nothing stands on top of it.
+ *
+ * Its top row rather than its height: the row is where the thing actually is,
+ * and a height has to be added to a guess about everything below it to mean
+ * anything. Published rather than assumed because it moves - the composer
+ * grows a slash menu upward and grows again with a wrapped draft, and the
+ * block that asks about a tool is only there while something is waiting.
+ * Cleared on the way out, or a screen that had one would keep making room for
+ * it after it had gone.
+ */
+export declare function useFloorTop(key: string, row: number): void;
+/**
+ * One animal per run, rather than one per component that draws one.
+ *
+ * Picked from the ones drawn moving, because the catalogue's is going to walk
+ * and the header's is the same creature seen at seven cells. Two screens
+ * showing two different animals would read as two mascots.
+ */
+export declare function pickBood(): string;
+/** The names, in roster order. */
+export declare const CREATURES: readonly string[];
+/** How tall the tallest of them is, for anyone deciding whether there is room. */
+export declare const CREATURE_HEIGHT: number;

package/dist/src/view/creature.js

@@ -0,0 +1,83 @@
+/**
+ * A small drawn thing, above the invitation to say something.
+ *
+ * An empty screen is the one place a client can afford a figure, and a
+ * different one each time is the difference between an application that has a
+ * mascot and one that has a habit.
+ *
+ * The drawings moved to [`bood/`](./bood/index.ts) - one creature per file,
+ * registered by name, in three sizes and five moods. This file is the door
+ * they were already behind, and it stays: `<Creature mood="happy" />` on the
+ * empty screen means what it always meant.
+ *
+ * Two rules, and both of them came from watching art break in a terminal.
+ *
+ * Plain ASCII, every character. Not one glyph is one whose width the terminal
+ * gets to decide - box drawing and the half-block set are the ones that get
+ * eaten by a CJK font setting, and art that is one cell wider on somebody
+ * else's machine does not look narrow, it looks broken. `registerCreature`
+ * checks this rather than trusting it.
+ *
+ * No shared frame, no shared face window, no shared size at full size. The
+ * figures run from seven cells wide to seventeen and the outline *is* the
+ * animal. A creature that fits a template is a template wearing a hat - which
+ * is exactly what `block` and `inline` are, and why they are drawn separately
+ * instead of being the big one shrunk.
+ */
+import { BOOD, boodHeight, livelyNames } from './bood/index.js';
+import { useApp, useEffect } from '@textui/core';
+import { boodFloorFor } from '../state.js';
+export { BoodSprite, Creature, MOODS, FORMS, creatureFrames, creatureMotion, creatureSize, drawCreature, livelyNames, } from './bood/index.js';
+/**
+ * What the figure is doing, from what the session is doing.
+ *
+ * The moods were always meant to be read off real state rather than chosen, and
+ * this is the only place the two vocabularies meet: five drawn moods, four
+ * activities the protocol actually reports. `sad` has no source and is drawn
+ * anyway, because a mood with nothing to trigger it is a drawing waiting for a
+ * state rather than a bug - and inventing a session state to justify it would
+ * be the tail wagging the dog.
+ *
+ * `input` is thinking rather than happy: a session waiting on a person has
+ * stopped, and the figure standing still and looking at you is the reading
+ * that matches the status row above it.
+ */
+export function moodOf(activity) {
+    return activity === 'running' ? 'executing'
+        : activity === 'error' ? 'error'
+            : activity === 'input' ? 'thinking'
+                : 'happy';
+}
+/**
+ * Say which row this component starts at, so nothing stands on top of it.
+ *
+ * Its top row rather than its height: the row is where the thing actually is,
+ * and a height has to be added to a guess about everything below it to mean
+ * anything. Published rather than assumed because it moves - the composer
+ * grows a slash menu upward and grows again with a wrapped draft, and the
+ * block that asks about a tool is only there while something is waiting.
+ * Cleared on the way out, or a screen that had one would keep making room for
+ * it after it had gone.
+ */
+export function useFloorTop(key, row) {
+    const app = useApp();
+    useEffect(() => {
+        app.store.set(boodFloorFor(key), row);
+        return () => app.store.set(boodFloorFor(key), 0);
+    }, [key, row]);
+}
+/**
+ * One animal per run, rather than one per component that draws one.
+ *
+ * Picked from the ones drawn moving, because the catalogue's is going to walk
+ * and the header's is the same creature seen at seven cells. Two screens
+ * showing two different animals would read as two mascots.
+ */
+export function pickBood() {
+    const names = livelyNames();
+    return names[Math.floor(Math.random() * names.length)];
+}
+/** The names, in roster order. */
+export const CREATURES = BOOD.map((creature) => creature.name);
+/** How tall the tallest of them is, for anyone deciding whether there is room. */
+export const CREATURE_HEIGHT = boodHeight('draw');

package/dist/src/view/customizations.d.ts

@@ -0,0 +1,28 @@
+import type { BoxProps, RenderOutput } from '@textui/core';
+import type { Customization } from '../ahp/types.js';
+/**
+ * What the host handed this session, as a list.
+ *
+ * One component for both panels, because a skill and an MCP server differ in
+ * what there is to say about them and not in how they are read: a name, where
+ * it came from, whether it is on, and - when the host has something to say
+ * about why it is not working - what it said. Two components would be the same
+ * two-line row twice with a different word in the third column.
+ *
+ * The list is flat and the container is the `from` column rather than a parent
+ * row, which is the arrangement the protocol's nesting does not survive
+ * anyway: an MCP server can be contributed by a plugin *or* by the host
+ * directly, and a tree would have to draw the second at a depth that means
+ * nothing. Sorting is the caller's.
+ */
+export interface CustomizationListProps extends BoxProps {
+    items: Customization[];
+    /** Enter on a row. Absent leaves the list read-only. */
+    onToggle?(item: Customization): void;
+    onSelect?(id: string): void;
+    selectedId?: string | null;
+    emptyMessage?: string;
+    focusId?: string;
+    autoFocus?: boolean;
+}
+export declare const CustomizationList: (props: CustomizationListProps) => RenderOutput;

package/dist/src/view/customizations.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
+import { defineComponent, stringWidth, useTheme } from '@textui/core';
+import { Column, List, Marquee, Row } from '@textui/widgets';
+/** What an MCP server's state means, in a word and a colour. */
+const MCP = {
+    starting: { label: 'starting', tone: 'warning' },
+    ready: { label: 'ready', tone: 'success' },
+    // Not an error: the server is reachable and nobody has signed in, which is
+    // something a person can go and fix rather than something that broke.
+    authRequired: { label: 'sign in', tone: 'warning' },
+    error: { label: 'failed', tone: 'danger' },
+    stopped: { label: 'stopped', tone: 'muted' },
+};
+export const CustomizationList = defineComponent('CustomizationList', (props) => {
+    const { items, onToggle, onSelect, selectedId, emptyMessage, focusId, autoFocus, ...rest } = props;
+    const theme = useTheme();
+    const dot = `  ${theme.glyphs.separator}  `;
+    const byId = new Map(items.map((item) => [item.id, item]));
+    const rows = items.map((item) => {
+        const mcp = item.state ? MCP[item.state] : null;
+        // The switch first, so the answer to "is this on" is in the same column
+        // on every row and findable without reading any of them.
+        const icon = item.enabled ? theme.glyphs.checkboxOn : theme.glyphs.checkboxOff;
+        return {
+            id: item.id,
+            icon,
+            label: item.name,
+            description: [
+                item.from ?? '',
+                item.description ?? '',
+                // Last, because it is the one that is usually not there and the one
+                // worth reading when it is.
+                item.problem ?? '',
+            ].filter(Boolean).join(dot),
+            meta: mcp?.label ?? (item.enabled ? '' : 'off'),
+            tone: (item.problem && !mcp
+                ? 'danger'
+                : mcp?.tone ?? (item.enabled ? 'muted' : 'subtle')),
+        };
+    });
+    return (_jsx(List, { items: rows, itemHeight: 2, renderItem: (row, state) => {
+            const item = byId.get(row.id);
+            return (_jsxs(Column, { children: [_jsxs(Row, { gap: 1, children: [_jsx("text", { content: row.icon ?? '', ...(state.selected ? {} : { fg: item?.enabled ? 'success' : 'subtle' }), shrink: 0 }), _jsx(Marquee, { content: row.label, active: state.selected && state.focused, flex: 1 }), _jsx("text", { content: row.meta ?? '', ...(state.selected ? {} : { fg: row.tone }), shrink: 0 })] }), _jsxs(Row, { children: [_jsx("text", { content: ' '.repeat(stringWidth(row.icon ?? '') + 1), shrink: 0 }), _jsx(Marquee, { content: row.description ?? '', active: state.selected && state.focused, ...(state.selected ? {} : { fg: 'muted' }), flex: 1 })] })] }));
+        }, ...(selectedId ? { selectedId } : {}), emptyMessage: emptyMessage ?? 'The host contributed none', ...(onSelect ? { onSelect } : {}), ...(onToggle
+            ? {
+                onActivate: (id) => {
+                    const item = byId.get(id);
+                    if (item)
+                        onToggle(item);
+                },
+            }
+            : {}), ...(focusId ? { focusId } : {}), ...(autoFocus ? { autoFocus: true } : {}), ...rest }));
+});

package/dist/src/view/details.d.ts

@@ -0,0 +1,65 @@
+import type { BoxProps, RenderOutput, SemanticVariant } from '@textui/core';
+/**
+ * A property list you can walk, and take a value out of.
+ *
+ * The catalogue's detail pane is where the identifiers live - a session URI, a
+ * chat URI - and an identifier you cannot read in full or paste anywhere is
+ * decoration. `KeyValue` draws the same pairs and is static: nothing selects a
+ * row, so nothing can be copied and nothing can be shown untruncated.
+ *
+ * So the selected row is the one that gets the room. Every other row is one
+ * line with its value truncated, and the selected row wraps its value across
+ * as many lines as it needs - which costs nothing when the value is short and
+ * is the whole answer when it is a URI in a 36-column pane. `enter` puts it on
+ * the clipboard.
+ *
+ * This is a finding, not a flourish: it is the third component this example
+ * wanted that the catalog does not have.
+ */
+export interface DetailField {
+    id: string;
+    label: string;
+    value: string;
+    tone?: SemanticVariant;
+    /** Shown instead of the value when there is none, in the subtle tone. */
+    absent?: string;
+}
+export interface SessionDetailsProps extends BoxProps {
+    fields: DetailField[];
+    focusId?: string;
+    /**
+     * Width of the label column, where a caller wants to fix it.
+     *
+     * Left off, it is the widest label there is. It used to be a constant on
+     * the grounds that the labels were ours, and they are not: a session's
+     * settings and a model's options are named by whichever host is answering,
+     * in words this client does not choose, and the constant was one character
+     * wider than the longest label anybody had thought of.
+     */
+    labelWidth?: number;
+    /**
+     * Take the keyboard on the frame this mounts, out of whatever holds it.
+     *
+     * Not `autoFocus`, which claims focus rather than taking it: a pane that
+     * appears *because* a key asked for it has to end up with the cursor, and
+     * the thing it is taking the cursor from - the session list - is in the
+     * same focus scope and already has it.
+     *
+     * It has to be done here rather than by the screen that mounts this,
+     * because a focusable registers in its own effect: on the render that opens
+     * the pane, the id does not exist yet and the screen's `focus()` is a call
+     * that quietly returns false.
+     */
+    claim?: boolean;
+    /**
+     * Which rows show their value whole.
+     *
+     * `selected` is the default and the one that keeps the pane a list: every
+     * row is one line, and the row you have stopped on wraps to as many as its
+     * value needs. `all` wraps every row, which is what you want when the
+     * values *are* the point - a pane of URIs where the answer is on the third
+     * one down and reading it should not mean walking there first.
+     */
+    values?: 'selected' | 'all';
+}
+export declare const SessionDetails: (props: SessionDetailsProps) => RenderOutput;

package/dist/src/view/details.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
+import { defineComponent, useClipboard, useEffect, useFocus, useInput, useState, useTheme, } from '@textui/core';
+import { Column, Row } from '@textui/widgets';
+export const SessionDetails = defineComponent('SessionDetails', (props) => {
+    const { fields, focusId, labelWidth, claim, values = 'selected', ...rest } = props;
+    // Floored at the eleven this used to be, so nothing that already fitted
+    // moves, and capped so one verbose title cannot take the pane from the
+    // values it is there to label.
+    const column = labelWidth ?? Math.min(20, Math.max(11, ...fields.map((field) => field.label.length)));
+    const theme = useTheme();
+    const clipboard = useClipboard();
+    const focus = useFocus({ ...(focusId ? { id: focusId } : {}) });
+    const [index, setIndex] = useState(0);
+    const [copied, setCopied] = useState(null);
+    // The selection is an index into a list that changes with the selected
+    // session, so it is clamped on the way out rather than reset on the way in.
+    const at = Math.max(0, Math.min(index, fields.length - 1));
+    // After the registration above, which is the whole point of it being here.
+    useEffect(() => { if (claim)
+        focus.focus(); }, [claim]);
+    useInput((event) => {
+        if (fields.length === 0)
+            return false;
+        switch (event.name) {
+            case 'up':
+                setIndex(Math.max(0, at - 1));
+                setCopied(null);
+                return true;
+            case 'down':
+                setIndex(Math.min(fields.length - 1, at + 1));
+                setCopied(null);
+                return true;
+            case 'home':
+                setIndex(0);
+                setCopied(null);
+                return true;
+            case 'end':
+                setIndex(fields.length - 1);
+                setCopied(null);
+                return true;
+            case 'enter': {
+                const field = fields[at];
+                if (!field || !field.value)
+                    return true;
+                // OSC 52 where the terminal takes it, and the store either way - so
+                // a test can assert what was copied without a terminal at all.
+                clipboard.write(field.value);
+                setCopied(field.id);
+                return true;
+            }
+            default: return false;
+        }
+    }, { focusId: focus.id });
+    return (_jsx(Column, { ...rest, id: focus.id, children: fields.map((field, i) => {
+            const active = i === at;
+            const selected = active && focus.focused;
+            const whole = values === 'all' || active;
+            return (
+            // `align="start"` because a wrapped value makes the row two lines
+            // tall and the label is one: centred, it drifted down to sit
+            // beside the *second* line of a URI, with nothing at all beside
+            // the first. A label names the row it starts.
+            _jsxs(Row, { gap: 1, align: "start", children: [_jsx("text", { content: active ? theme.glyphs.chevronRight : ' ', fg: selected ? 'accent' : 'subtle', shrink: 0 }), _jsx("text", { content: field.label, width: column, shrink: 0, fg: "muted", truncate: "end" }), _jsx("text", { content: field.value || field.absent || '-', flex: 1, ...(whole ? { wrap: 'word' } : { truncate: 'end' }), ...(field.value ? {} : { fg: 'subtle' }), ...(field.tone && field.value ? { fg: field.tone } : {}), ...(selected ? { bold: true } : {}) }), copied === field.id ? _jsx("text", { content: "copied", fg: "success", shrink: 0 }) : null] }, field.id));
+        }) }));
+});

package/dist/src/view/filediff.d.ts

@@ -0,0 +1,29 @@
+import type { BoxProps, RenderOutput } from '@textui/core';
+import type { DiffResult } from '../diff.js';
+/**
+ * One file out of a changeset, both sides of it.
+ *
+ * Unified rather than side by side, and not for want of a splitter: a terminal
+ * that a changeset list already shares with a session pane has sixty columns
+ * left, and eighty characters of source in thirty is two columns of nothing
+ * legible. Unified spends the width on the line instead.
+ *
+ * Every row is exactly one row tall. The scroll position is a row count, so a
+ * line that wrapped would put the gutter numbers out of step with what is on
+ * screen - which is the same invariant the markdown layout keeps, for the same
+ * reason. Long lines are clipped, and the file is there to be read rather than
+ * edited.
+ */
+export interface FileDiffProps extends BoxProps {
+    /** The file, as the changeset names it. */
+    path: string;
+    diff: DiffResult;
+    /** Absent `before` is a creation, absent `after` a deletion. */
+    kind: 'new' | 'edited' | 'deleted';
+    /** Set instead of a diff when the bytes are not text. */
+    binary?: {
+        bytes: number;
+        contentType?: string;
+    };
+}
+export declare const FileDiff: (props: FileDiffProps) => RenderOutput;

package/dist/src/view/filediff.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
+import { defineComponent, useTheme } from '@textui/core';
+import { Column, EmptyState, Row, ScrollView } from '@textui/widgets';
+export const FileDiff = defineComponent('FileDiff', (props) => {
+    const { path, diff, kind, binary, ...rest } = props;
+    const theme = useTheme();
+    if (binary) {
+        return (_jsx(EmptyState, { title: "Not text", message: `${binary.contentType ?? 'Binary'}, ${binary.bytes} bytes. There is nothing to show a line at a time.`, ...rest }));
+    }
+    if (diff.tooLarge) {
+        return (_jsx(EmptyState, { title: "Too big to line up", message: `${diff.tooLarge.lines} lines between the two sides, over the ${diff.tooLarge.limit} this will compare. Open it in an editor.`, ...rest }));
+    }
+    if (diff.rows.length === 0) {
+        return _jsx(EmptyState, { title: "Nothing between the two", message: "Both sides of this file are the same.", ...rest });
+    }
+    // The widest line number either side will need, so the gutter does not
+    // change width partway down the file.
+    const width = String(Math.max(...diff.rows.map((row) => Math.max(row.before ?? 0, row.after ?? 0)))).length;
+    return (_jsxs(Column, { ...rest, children: [_jsxs(Row, { gap: 1, children: [_jsx("text", { content: kind === 'new' ? '+' : kind === 'deleted' ? '-' : theme.glyphs.chevronRight, fg: kind === 'new' ? 'success' : kind === 'deleted' ? 'danger' : 'muted', shrink: 0 }), _jsx("text", { content: path, flex: 1, truncate: "start" }), _jsx("text", { content: `+${diff.added}`, fg: "success", shrink: 0 }), _jsx("text", { content: `-${diff.removed}`, fg: "danger", shrink: 0 })] }), _jsx(ScrollView, { flex: 1, focusId: "changes.file", children: _jsx(Column, { children: diff.rows.map((row, index) => (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: String(row.before ?? '').padStart(width), fg: "subtle", shrink: 0 }), _jsx("text", { content: String(row.after ?? '').padStart(width), fg: "subtle", shrink: 0 }), _jsx("text", { content: row.kind === 'added' ? '+' : row.kind === 'removed' ? '-' : ' ', fg: row.kind === 'added' ? 'success' : row.kind === 'removed' ? 'danger' : 'muted', shrink: 0 }), _jsx("text", { content: row.text, wrap: "none", truncate: "end", flex: 1, ...(row.kind === 'added'
+                                    ? { fg: 'success' }
+                                    : row.kind === 'removed'
+                                        ? { fg: 'danger' }
+                                        : {}) })] }, index))) }) })] }));
+});

package/dist/src/view/files.d.ts

@@ -0,0 +1,31 @@
+import type { BoxProps, RenderOutput } from '@textui/core';
+import type { ResourceEntry } from '../ahp/types.js';
+/**
+ * One directory of the host's filesystem.
+ *
+ * The *host's*, which is the only thing about this screen worth stating twice:
+ * the daemon may be on another machine, and the tree being walked is the one
+ * the agent is working in rather than the one this terminal is sitting on. A
+ * client that listed its own directory would be showing the right shape and
+ * the wrong files.
+ *
+ * A `List` for the same reason the changeset is one - the selection, the keys,
+ * the window and the highlight are the list's - and one directory at a time
+ * rather than a tree, because `resourceList` answers about one directory and
+ * expanding a node would be a request per node with nothing to show meanwhile.
+ */
+export interface FileListProps extends BoxProps {
+    /** Where this is looking, as a `file://` URI on the host. */
+    at: string;
+    entries: ResourceEntry[];
+    loading?: boolean;
+    /** What the host said when it would not answer. */
+    failure?: string;
+    /** Enter on a row: a directory to descend into, or a file to open. */
+    onOpen?(entry: ResourceEntry): void;
+    /** Up out of this directory. Absent at the top of what the host serves. */
+    onUp?(): void;
+    focusId?: string;
+    autoFocus?: boolean;
+}
+export declare const FileList: (props: FileListProps) => RenderOutput;

package/dist/src/view/files.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
+import { defineComponent, useTheme } from '@textui/core';
+import { Column, EmptyState, List, Marquee, Row } from '@textui/widgets';
+export const FileList = defineComponent('FileList', (props) => {
+    const { at, entries, loading, failure, onOpen, onUp, focusId, autoFocus, ...rest } = props;
+    const theme = useTheme();
+    if (failure !== undefined) {
+        // The host's own words. A host that serves no filesystem answers
+        // `-32601`, and a blank pane would be this client looking broken for
+        // something the host said plainly.
+        return _jsx(EmptyState, { title: "The host would not list it", message: failure, ...rest });
+    }
+    if (loading === true)
+        return _jsx(EmptyState, { title: "Reading the directory", ...rest });
+    const items = [
+        // The way up, as a row rather than a key, because it is where a person
+        // looks for it and because a key that only works sometimes is worse.
+        ...(onUp ? [{ id: '..', icon: theme.glyphs.chevronUp, label: '..', tone: 'muted' }] : []),
+        ...entries.map((entry) => ({
+            id: entry.uri,
+            icon: entry.kind === 'directory' ? theme.glyphs.chevronRight : ' ',
+            label: entry.name,
+            // Bytes only for files. A size against a directory is a number about
+            // the directory entry rather than about what is in it.
+            meta: entry.kind === 'directory' ? '' : String(entry.size ?? ''),
+            tone: (entry.kind === 'directory' ? 'accent' : 'muted'),
+        })),
+    ];
+    const byId = new Map(entries.map((entry) => [entry.uri, entry]));
+    return (_jsxs(Column, { ...rest, children: [_jsx(Marquee, { content: at.replace(/^file:\/\//, ''), truncate: "start", fg: "muted" }), _jsx(List, { items: items, flex: 1, renderItem: (item, state) => (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: item.icon ?? ' ', ...(state.selected ? {} : { fg: item.tone }), shrink: 0 }), _jsx(Marquee, { content: item.label, active: state.selected && state.focused, truncate: "end", flex: 1 }), _jsx("text", { content: item.meta ?? '', fg: "muted", shrink: 0 })] })), onActivate: (id) => {
+                    if (id === '..') {
+                        onUp?.();
+                        return;
+                    }
+                    const found = byId.get(id);
+                    if (found)
+                        onOpen?.(found);
+                }, ...(focusId ? { focusId } : {}), ...(autoFocus ? { autoFocus: true } : {}), emptyMessage: "Nothing here" })] }));
+});

package/dist/src/view/hitl.d.ts

@@ -0,0 +1,43 @@
+import type { BindingPath, BoxProps, RenderOutput } from '@textui/core';
+import type { Answer, PendingInput } from '../ahp/types.js';
+/**
+ * The block that means the agent is stopped, waiting on a person.
+ *
+ * It is the only thing on the screen that is waiting on the reader, so it
+ * takes the focus, traps it, and is answerable without leaving the keyboard.
+ * Rendered as one more bubble in the transcript it scrolls away, and a blocked
+ * agent that has scrolled off is a session that looks merely slow.
+ *
+ * Two kinds, and they are nothing alike:
+ *
+ *   a **tool confirmation** is a yes or a no about a command, with named
+ *   options where the host offers them;
+ *
+ *   a **question** carries no tool call at all. Its prose is the request's own
+ *   message and what is being asked is its questions. Rendering it as a
+ *   confirmation loses the entire request - the choices vanish, the question
+ *   is never shown, and what is left is a heading and an Approve button.
+ */
+export declare const ANSWERS: BindingPath;
+export interface ChatHitlProps extends BoxProps {
+    input: PendingInput;
+    onApprove(optionId?: string): void;
+    onDeny(): void;
+    onAnswer(answers: Record<string, Answer>, accepted: boolean): void;
+    /** Leave it up, but give the keyboard back. */
+    onEscape?(): void;
+}
+export declare const ChatHitl: (props: ChatHitlProps) => RenderOutput;
+/**
+ * What came of the answer, on the row between the block and the composer.
+ *
+ * That row was a blank one, and it is where a person is already looking after
+ * pressing a button on the block above it. A press that reaches a host which
+ * then says nothing is indistinguishable from a key that was never read - so
+ * this says the answer has gone, and says so in red when it did not.
+ *
+ * Nothing to say is no row rather than an empty one: a status line that is
+ * always there is a row of chrome, and the composer is a row further from the
+ * conversation for the whole of every session in which nothing goes wrong.
+ */
+export declare const ChatInputStatus: (props: BoxProps) => RenderOutput;