@softov/ahpc 0.3.0 → 0.4.0

package/dist/src/wiretui.js

@@ -0,0 +1,69 @@
+/**
+ * `ahpc wire <file>`: a capture, watched.
+ *
+ * A screen with no host behind it. On a terminal it is the wire screen,
+ * reading the file as it grows; anywhere else it is one line per frame to
+ * stdout, which is what a shell wants from it. Loaded only when asked for,
+ * for the same reason the conversation screen is: it pulls in a renderer,
+ * and `ahpc session list` should not pay for one.
+ */
+import { WRITER_KEY, createApp } from '@textui/core';
+import { createNodeTerminal, createWriter } from '@textui/terminal';
+import { registerWire } from './view/wire.js';
+import { follow, matches, rowText } from './wire.js';
+/** The screen, or the lines. */
+export async function wireTui(options) {
+    if (!process.stdout.isTTY || options.json) {
+        await new Promise((resolve) => {
+            let quiet;
+            const done = () => { reader.close(); resolve(); };
+            const reader = follow(options.file, (rows) => {
+                for (const row of rows) {
+                    if (options.filter !== undefined && !matches(row, options.filter))
+                        continue;
+                    process.stdout.write(options.json ? `${JSON.stringify(row)}\n` : `${rowText(row)}\n`);
+                }
+                if (!options.follow) {
+                    if (quiet)
+                        clearTimeout(quiet);
+                    quiet = setTimeout(done, 50);
+                }
+            });
+            // Without `--follow`, what is there now and then out: the first read
+            // is synchronous, so nothing arriving in the next moment means the
+            // file has been read to its end.
+            if (!options.follow && quiet === undefined)
+                quiet = setTimeout(done, 50);
+        });
+        return;
+    }
+    const terminal = createNodeTerminal();
+    const app = createApp({
+        terminal,
+        ...(options.theme ? { theme: options.theme } : {}),
+        ...(options.shell ? { shell: options.shell } : {}),
+        session: { managed: true, altScreen: true, mouse: true, title: 'wire' },
+        onBoot: (booted) => {
+            registerWire(booted, { file: options.file });
+            booted.commands.register({
+                id: 'app.quit',
+                title: 'Quit',
+                slots: ['palette'],
+                run: () => void app.stop().then(() => process.exit(0)),
+            });
+            booted.keybindings.register({ keys: 'ctrl+c', commandId: 'app.quit' });
+            booted.keybindings.register({ keys: 'ctrl+q', commandId: 'app.quit' });
+            booted.keybindings.register({ keys: 'q', commandId: 'app.quit', scopeId: 'wire.rows' });
+        },
+    });
+    app.services.provide(WRITER_KEY, createWriter(terminal.capabilities()));
+    await app.start();
+    const bail = (label) => (error) => {
+        void app.stop().finally(() => {
+            process.stderr.write(`${label}: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+            process.exit(1);
+        });
+    };
+    process.on('unhandledRejection', bail('Unhandled rejection'));
+    process.on('uncaughtException', bail('Uncaught exception'));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softov/ahpc",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "A terminal client for the Agent Host Protocol: sessions, a streaming transcript, and interactive prompts",
   "keywords": [
@@ -54,12 +54,13 @@
   },
   "dependencies": {
     "@microsoft/agent-host-protocol": "^0.9.0",
-    "@textui/core": "^0.5.0",
-    "@textui/terminal": "^0.5.0",
-    "@textui/widgets": "^0.5.0"
+    "@textui/chat": "^0.6.1",
+    "@textui/core": "^0.6.1",
+    "@textui/terminal": "^0.6.1",
+    "@textui/widgets": "^0.6.1"
   },
   "devDependencies": {
-    "@textui/testing": "^0.5.0",
+    "@textui/testing": "^0.6.1",
     "@types/node": "^22.10.2",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",

package/dist/src/diff.d.ts

@@ -1,44 +0,0 @@
-/**
- * A line diff, small enough to read.
- *
- * The host sends two whole files and a count of what changed between them; it
- * does not send the diff itself, so somebody has to work out which lines those
- * were. This is that, and it is deliberately the textbook algorithm rather
- * than anything clever: the longest common subsequence of the two line arrays,
- * with everything not in it marked as removed on the left or added on the
- * right.
- *
- * The cost is quadratic in the number of lines, which is why `diffLines` takes
- * a ceiling. Two files of ten thousand lines each is a hundred million cells
- * and a terminal that stops answering, and the honest answer at that size is
- * to say the files are too big rather than to spend a minute proving it.
- */
-export type DiffKind = 'same' | 'added' | 'removed';
-export interface DiffRow {
-    kind: DiffKind;
-    /** 1-based, on the side this row exists on. Absent on the side it does not. */
-    before?: number;
-    after?: number;
-    text: string;
-}
-export interface DiffResult {
-    rows: DiffRow[];
-    added: number;
-    removed: number;
-    /** Set instead of a diff when the pair was over `limit`. */
-    tooLarge?: {
-        lines: number;
-        limit: number;
-    };
-}
-/** Lines of a file, with the trailing newline not counted as an empty last line. */
-export declare function toLines(text: string): string[];
-/**
- * The two sides, lined up.
- *
- * A creation has no `before` and a deletion no `after`; both are passed as an
- * empty string rather than as a special case, because "every line is an
- * addition" is exactly the right diff for a new file and needs no branch of
- * its own.
- */
-export declare function diffLines(before: string, after: string, limit?: number): DiffResult;

package/dist/src/diff.js

@@ -1,111 +0,0 @@
-/**
- * A line diff, small enough to read.
- *
- * The host sends two whole files and a count of what changed between them; it
- * does not send the diff itself, so somebody has to work out which lines those
- * were. This is that, and it is deliberately the textbook algorithm rather
- * than anything clever: the longest common subsequence of the two line arrays,
- * with everything not in it marked as removed on the left or added on the
- * right.
- *
- * The cost is quadratic in the number of lines, which is why `diffLines` takes
- * a ceiling. Two files of ten thousand lines each is a hundred million cells
- * and a terminal that stops answering, and the honest answer at that size is
- * to say the files are too big rather than to spend a minute proving it.
- */
-/** Lines of a file, with the trailing newline not counted as an empty last line. */
-export function toLines(text) {
-    if (text === '')
-        return [];
-    const lines = text.split('\n');
-    if (lines[lines.length - 1] === '')
-        lines.pop();
-    return lines;
-}
-/**
- * The two sides, lined up.
- *
- * A creation has no `before` and a deletion no `after`; both are passed as an
- * empty string rather than as a special case, because "every line is an
- * addition" is exactly the right diff for a new file and needs no branch of
- * its own.
- */
-export function diffLines(before, after, limit = 4000) {
-    const a = toLines(before);
-    const b = toLines(after);
-    if (a.length + b.length > limit) {
-        return { rows: [], added: 0, removed: 0, tooLarge: { lines: a.length + b.length, limit } };
-    }
-    // The common head and tail first. Two files that differ in one line share
-    // everything either side of it, and taking those off shrinks the table the
-    // quadratic part has to fill to the part that actually differs.
-    let head = 0;
-    while (head < a.length && head < b.length && a[head] === b[head])
-        head++;
-    let tail = 0;
-    while (tail < a.length - head
-        && tail < b.length - head
-        && a[a.length - 1 - tail] === b[b.length - 1 - tail])
-        tail++;
-    const midA = a.slice(head, a.length - tail);
-    const midB = b.slice(head, b.length - tail);
-    const table = lcs(midA, midB);
-    const rows = [];
-    let added = 0;
-    let removed = 0;
-    const push = (kind, text, ai, bi) => {
-        rows.push({
-            kind,
-            ...(kind !== 'added' ? { before: ai + 1 } : {}),
-            ...(kind !== 'removed' ? { after: bi + 1 } : {}),
-            text,
-        });
-        if (kind === 'added')
-            added++;
-        if (kind === 'removed')
-            removed++;
-    };
-    for (let i = 0; i < head; i++)
-        push('same', a[i], i, i);
-    // Walking the table forwards, so the rows come out in file order.
-    let i = 0;
-    let j = 0;
-    while (i < midA.length || j < midB.length) {
-        if (i < midA.length && j < midB.length && midA[i] === midB[j]) {
-            push('same', midA[i], head + i, head + j);
-            i++;
-            j++;
-            // A tie goes to the removal, so a replaced line reads `-old` then `+new`
-            // the way every other diff on the machine prints it. With `>=` here the
-            // pair comes out the other way round, which is not wrong so much as
-            // unreadable next to `git diff`.
-        }
-        else if (j < midB.length && (i === midA.length || (table[i]?.[j + 1] ?? 0) > (table[i + 1]?.[j] ?? 0))) {
-            push('added', midB[j], head + i, head + j);
-            j++;
-        }
-        else {
-            push('removed', midA[i], head + i, head + j);
-            i++;
-        }
-    }
-    for (let k = 0; k < tail; k++) {
-        push('same', a[a.length - tail + k], a.length - tail + k, b.length - tail + k);
-    }
-    return { rows, added, removed };
-}
-/**
- * `table[i][j]` is the length of the longest common subsequence of `a[i..]`
- * and `b[j..]`, filled from the end so the walk above can go forwards.
- */
-function lcs(a, b) {
-    const table = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
-    for (let i = a.length - 1; i >= 0; i--) {
-        for (let j = b.length - 1; j >= 0; j--) {
-            table[i][j] = a[i] === b[j]
-                ? (table[i + 1]?.[j + 1] ?? 0) + 1
-                : Math.max(table[i + 1]?.[j] ?? 0, table[i]?.[j + 1] ?? 0);
-        }
-    }
-    return table;
-}

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

@@ -1,75 +0,0 @@
-import type { BoxProps, RenderOutput, SemanticVariant } from '@textui/core';
-/**
- * One thing said, and the two ways it is still being said.
- *
- * A bubble in a terminal is not a rounded rectangle. It is a gutter that says
- * who is speaking and a body that owns the rest of the width - because the
- * width is 80 cells and half of it spent on alignment is half the conversation
- * gone.
- */
-export type Speaker = 'user' | 'agent' | 'system';
-/**
- * The rule down the left of everything one speaker said.
- *
- * A box that fills rather than a `text`: the text is one row tall and the
- * paragraph beside it is nine, so a rule written as a character marks the
- * first line of a wrapped answer and abandons the rest of it.
- */
-export declare const Gutter: (props: BoxProps) => RenderOutput;
-export interface ChatBubbleProps extends BoxProps {
-    speaker: Speaker;
-    /** The name, when the speaker is not enough: a model, a person, a host. */
-    author?: string;
-    /** Right of the author line: a time, a duration, a model. */
-    meta?: string;
-    tone?: SemanticVariant;
-    /** The transcript's cursor is on this block. */
-    active?: boolean;
-    children?: unknown;
-}
-export declare const ChatBubble: (props: ChatBubbleProps) => RenderOutput;
-export interface StreamingTextProps extends BoxProps {
-    content: string;
-    /** Still arriving. Draws a caret and keeps it on the last word. */
-    streaming?: boolean;
-    quiet?: boolean;
-    maxLines?: number;
-    /**
-     * Draw it as markdown, or as the characters that arrived.
-     *
-     * Unstated it follows the application's own switch, which is what the key
-     * that toggles it moves - so a caller has to say something here only when
-     * it wants one or the other regardless.
-     */
-    markdown?: boolean;
-    /** Text to pick out, for the find box. Coloured wherever it appears. */
-    match?: string;
-}
-/**
- * Text that is still being said.
- *
- * The caret is part of the content rather than a node beside it, because a
- * caret placed after the block sits under the last line instead of at the end
- * of it - and the end of the sentence is the only place it means anything.
- *
- * It blinks on the theme's own ticker, so animation being off (a pipe, a test,
- * a `--static` capture) leaves a steady caret rather than a missing one.
- */
-export declare const StreamingText: (props: StreamingTextProps) => RenderOutput;
-export interface ReasoningBlockProps extends BoxProps {
-    /** Text to pick out, for the find box. Handed to the text inside it. */
-    match?: string;
-    content: string;
-    expanded?: boolean;
-    streaming?: boolean;
-    /** Shown collapsed: "thought for 12s". */
-    summary?: string;
-}
-/**
- * What the agent was thinking, folded away.
- *
- * Reasoning is prose the host sends like any other, and it is not what the
- * reader came for - so it is one row until it is asked for. Dropping it
- * instead loses the only account of *why* a turn did what it did.
- */
-export declare const ReasoningBlock: (props: ReasoningBlockProps) => RenderOutput;

package/dist/src/view/bubble.js

@@ -1,86 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
-import { defineComponent, useFrame, useStoreValue, useTheme } from '@textui/core';
-import { Column, MarkdownView, Row } from '@textui/widgets';
-import { MARKDOWN } from '../state.js';
-/**
- * The rule down the left of everything one speaker said.
- *
- * A box that fills rather than a `text`: the text is one row tall and the
- * paragraph beside it is nine, so a rule written as a character marks the
- * first line of a wrapped answer and abandons the rest of it.
- */
-export const Gutter = defineComponent('ChatGutter', (props) => {
-    const theme = useTheme();
-    // `alignSelf` because `Row` centres its children: a one-cell box in a
-    // centred row is one cell tall, wherever the rule was meant to reach.
-    return _jsx("box", { width: 1, alignSelf: "stretch", fill: theme.borderChars().left, fg: "borderSubtle", ...props });
-});
-const SPEAKER = {
-    user: { fg: 'primary', label: 'you' },
-    agent: { fg: 'accent', label: 'agent' },
-    system: { fg: 'muted', label: 'system' },
-};
-export const ChatBubble = defineComponent('ChatBubble', (props) => {
-    const { speaker, author, meta, tone, active, children, ...rest } = props;
-    const theme = useTheme();
-    const look = SPEAKER[speaker];
-    const glyph = speaker === 'user' ? theme.glyphs.chevronRight
-        : speaker === 'agent' ? theme.glyphs.bulletFilled
-            : theme.glyphs.info;
-    // The gutter is one column of glyph and one of rule. It is what makes a
-    // wrapped paragraph read as one person talking rather than as the page
-    // starting again, and it survives losing colour - which a tinted
-    // background does not.
-    return (_jsxs(Column, { ...rest, ...(active ? { bg: 'selected' } : {}), children: [_jsxs(Row, { gap: 1, children: [_jsx("text", { content: glyph, fg: tone ?? look.fg }), _jsx("text", { content: author ?? look.label, bold: true, fg: tone ?? look.fg }), meta ? _jsx("text", { content: meta, fg: "subtle", flex: 1, truncate: "end" }) : _jsx("text", { content: "", flex: 1 })] }), _jsxs(Row, { gap: 1, flex: 1, children: [_jsx(Gutter, {}), _jsx(Column, { flex: 1, gap: 1, children: children })] })] }));
-});
-/**
- * Text that is still being said.
- *
- * The caret is part of the content rather than a node beside it, because a
- * caret placed after the block sits under the last line instead of at the end
- * of it - and the end of the sentence is the only place it means anything.
- *
- * It blinks on the theme's own ticker, so animation being off (a pipe, a test,
- * a `--static` capture) leaves a steady caret rather than a missing one.
- */
-export const StreamingText = defineComponent('StreamingText', (props) => {
-    const { content, streaming, quiet, maxLines, markdown, match, ...rest } = props;
-    const theme = useTheme();
-    // Only while something is arriving. A ticker marks its component dirty
-    // whether or not the frame it produces differs, so an unconditional one
-    // here meant every settled paragraph in the transcript asked the
-    // application to redraw twice a second, for ever - a conversation that
-    // got heavier to sit in the longer it got.
-    const frame = useFrame(2, { enabled: streaming === true });
-    const caret = streaming && frame % 2 === 0 ? theme.glyphs.caret : '';
-    // Read unconditionally: `??` short-circuits, and a hook that is only
-    // reached when a prop is absent is a hook that changes position between
-    // renders. The prop still wins - it is just decided after the read.
-    const preference = useStoreValue(MARKDOWN, true) ?? true;
-    const rendered = markdown ?? preference;
-    const shown = streaming ? `${content}${caret}` : content;
-    // Raw is a `text`, not a `MarkdownView` that was told not to parse: the
-    // point of turning it off is to see the characters that arrived, and
-    // anything that lays the document out has already decided some of them
-    // were structure. `wrap` rather than truncate, because the lines being
-    // read are the long ones - a fenced block and a table are exactly what is
-    // wider than the pane.
-    if (!rendered) {
-        return (_jsx("text", { content: shown, wrap: "word", ...(quiet ? { fg: 'muted' } : {}), ...(match ? { match } : {}), ...rest }));
-    }
-    return (_jsx(MarkdownView, { content: shown, ...(quiet ? { quiet: true } : {}), ...(maxLines !== undefined ? { maxLines } : {}), ...(match ? { match } : {}), ...rest }));
-});
-/**
- * What the agent was thinking, folded away.
- *
- * Reasoning is prose the host sends like any other, and it is not what the
- * reader came for - so it is one row until it is asked for. Dropping it
- * instead loses the only account of *why* a turn did what it did.
- */
-export const ReasoningBlock = defineComponent('ReasoningBlock', (props) => {
-    const { content, expanded, streaming, summary, match, ...rest } = props;
-    const theme = useTheme();
-    const chevron = expanded ? theme.glyphs.chevronDown : theme.glyphs.chevronRight;
-    const words = content.trim().split(/\s+/).filter(Boolean).length;
-    return (_jsxs(Column, { ...rest, children: [_jsxs(Row, { gap: 1, children: [_jsx("text", { content: chevron, fg: "subtle" }), _jsx("text", { content: summary ?? (streaming ? 'thinking' : `thought, ${words} words`), fg: "subtle", italic: true })] }), expanded ? (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: " " }), _jsx(StreamingText, { content: content, quiet: true, flex: 1, ...(streaming ? { streaming: true } : {}), ...(match ? { match } : {}) })] })) : null] }));
-});

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

@@ -1,64 +0,0 @@
-import type { BoxProps, RenderOutput } from '@textui/core';
-import type { Completion, SlashCommand } from '../ahp/types.js';
-import type { ComposerOption } from './controls.js';
-/**
- * What you type, and one line saying what it will be sent as.
- *
- * The field itself is `TextArea` from the catalog - growing, scrolling and
- * giving back the keys it does not want is not a chat problem. What is here is
- * the rest of a composer: what enter means while a turn is running, the slash
- * menu over what has already been typed, and the control row.
- *
- * The row used to be four ghost buttons naming their own keys - `send enter`,
- * `newline alt+enter`, `stop ctrl+c`, `commands ctrl+p` - which spent the one
- * line under the field on a keyboard legend. The keys belong in the footer,
- * which already lists them and changes with where the focus is. The line under
- * the field is worth more as *what is about to happen*: which harness, which
- * model, what it may do without asking, where it runs.
- */
-export interface ChatComposerProps extends BoxProps {
-    value: string;
-    onChange(value: string): void;
-    onSubmit(value: string): void;
-    onCancel?(): void;
-    onHistory?(direction: -1 | 1): void;
-    /** Left off the front of the field: out of the composer entirely. */
-    onLeave?(): void;
-    /** A turn is running: enter queues rather than sends, and stop is offered. */
-    running?: boolean;
-    queued?: number;
-    /** The control row. Each is a value, and each may open a picker. */
-    options?: ComposerOption[];
-    onOption?(option: ComposerOption, anchorId: string): void;
-    placeholder?: string;
-    /** Offered when the draft starts with a slash. */
-    commands?: SlashCommand[];
-    /**
-     * One of `commands` was chosen from the slash menu.
-     *
-     * The whole command rather than its id, because the two kinds go different
-     * places and only the command knows which it is. A `client` command is
-     * *ours*: it opens a screen, changes a setting or picks a theme, and none of
-     * that is a message - sending it down the session channel would put
-     * "/theme" in the transcript and ask the agent to make sense of it. A
-     * `session` command is a skill the host contributed, and the only way to
-     * invoke one is to send its name as the message.
-     *
-     * A slash the menu does not match is left alone and sent, which is how a
-     * command the host offers but did not list still reaches it.
-     */
-    onCommand?(command: SlashCommand): void;
-    /**
-     * What the host offers to complete the word the caret is in.
-     *
-     * Fetched rather than filtered: a path is a path on the *host's*
-     * filesystem, so which of them match what has been typed is a question only
-     * it can answer, and the answer changes with every keystroke.
-     */
-    paths?: Completion[];
-    /** One of `paths` was chosen. The range it replaces is on the completion. */
-    onPath?(path: Completion): void;
-    autoFocus?: boolean;
-    focusId?: string;
-}
-export declare const ChatComposer: (props: ChatComposerProps) => RenderOutput;