@softov/ahpc 0.1.0

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

@@ -0,0 +1,27 @@
+import type { BoxProps, RenderOutput } from '@textui/core';
+import type { ToolCall } from '../ahp/types.js';
+/**
+ * A tool call, as a row.
+ *
+ * Twenty of these in a turn look identical unless the *command* is on the row,
+ * so the input is the row and the display name is a prefix. What it meant to
+ * do is markdown, like everything else a host writes for a person; what came
+ * back is not, and is shown as it arrived.
+ *
+ * The status is a glyph and a colour together. A 16-colour session, a piped
+ * log and a colourblind reader all lose the colour and keep the glyph.
+ *
+ * It sits at the turn's own left edge rather than inside the gutter, with its
+ * status glyph where the header's bullet is. A tool call is something the
+ * agent *did*; indenting it inside the rule filed it under what the agent was
+ * saying, which is the one thing it is not.
+ */
+export interface ToolCallRowProps extends BoxProps {
+    call: ToolCall;
+    expanded?: boolean;
+    /** The transcript's cursor is on this row. */
+    active?: boolean;
+    /** Clicking the row opens it. */
+    onToggle?(): void;
+}
+export declare const ToolCallRow: (props: ToolCallRowProps) => RenderOutput;

package/dist/src/view/toolcall.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
+import { defineComponent, useTheme } from '@textui/core';
+import { Badge, Column, MarkdownView, Row } from '@textui/widgets';
+const LOOK = {
+    pending: { tone: 'muted', glyph: 'bulletHollow' },
+    'pending-confirmation': { tone: 'warning', glyph: 'bulletHalf' },
+    running: { tone: 'accent', glyph: 'bulletFilled' },
+    completed: { tone: 'success', glyph: 'check' },
+    failed: { tone: 'danger', glyph: 'cross' },
+    cancelled: { tone: 'muted', glyph: 'cross' },
+};
+/**
+ * The input, as one line.
+ *
+ * A tool's arguments are often JSON, and JSON arrives with newlines in it. Put
+ * straight on the row, a three-line object makes the row three lines tall and
+ * every other cell in it vertically centred - so the name floats beside the
+ * middle line of a brace-delimited block. The whole thing is on its own lines
+ * once the row is opened; this is the part that fits beside a name.
+ */
+function oneLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+export const ToolCallRow = defineComponent('ToolCallRow', (props) => {
+    const { call, expanded, active, onToggle, ...rest } = props;
+    const theme = useTheme();
+    const look = LOOK[call.status] ?? { tone: 'muted', glyph: 'bulletHollow' };
+    const glyph = theme.glyphs[look.glyph];
+    const chevron = expanded ? theme.glyphs.chevronDown : theme.glyphs.chevronRight;
+    const failed = call.status === 'failed' || (call.exitCode !== undefined && call.exitCode !== 0);
+    const summary = oneLine(call.input ?? call.intention ?? '');
+    // Only when there is something under it. A chevron on a row that opens on
+    // to nothing is a promise the row cannot keep.
+    const opens = Boolean(call.intention ?? call.input ?? call.output ?? call.outcome
+        ?? (call.files && call.files.length > 0));
+    return (_jsxs(Column, { ...rest, ...(active ? { bg: 'selected' } : {}), children: [_jsxs(Row, { gap: 1, ...(opens && onToggle ? { onClick: onToggle } : {}), 
+                // The whole row lights up, not the glyph the pointer happens to be
+                // over: the row is the thing that opens.
+                style: { hover: { bg: 'hover' } }, children: [_jsx("text", { content: glyph, fg: look.tone }), _jsx("text", { content: call.name, bold: true }), _jsx("text", { content: summary, fg: "muted", flex: 1, truncate: "middle" }), call.status === 'pending-confirmation' ? _jsx(Badge, { label: "asks", tone: "warning", icon: theme.glyphs.warning }) : null, failed ? _jsx(Badge, { label: `exit ${call.exitCode ?? 1}`, tone: "danger" }) : null, opens ? _jsx("text", { content: chevron, fg: "subtle" }) : null] }), expanded ? (
+            // Indented to the row's own text, which starts one glyph and one gap
+            // in - so what opened out of a row lines up under it.
+            _jsxs(Column, { padding: [0, 0, 0, 2], gap: 0, children: [call.intention && call.intention !== call.name && call.intention !== call.input
+                        ? _jsx(MarkdownView, { content: call.intention, quiet: true })
+                        : null, call.input ? (
+                    // On its own lines, wrapped as written. This is where the JSON
+                    // goes: whole, and not sharing a row with the name.
+                    _jsx(Column, { bg: "surfaceAlt", padding: [0, 1], children: call.input.split('\n').map((line, i) => (_jsx("text", { content: line, fg: "text", wrap: "word" }, i))) })) : null, call.output ? (_jsxs(Column, { children: [call.output.split('\n').slice(0, 12).map((line, i) => (_jsx("text", { content: line, fg: "muted", truncate: "end" }, i))), call.output.split('\n').length > 12 ? (_jsx("text", { content: `${theme.glyphs.ellipsis} ${call.output.split('\n').length - 12} more lines`, fg: "subtle" })) : null] })) : null, call.files && call.files.length > 0 ? (_jsx(Column, { children: call.files.map((file) => (_jsx("text", { content: `${theme.glyphs.chevronRight} ${file}`, fg: "info" }, file))) })) : null, call.outcome ? _jsx("text", { content: call.outcome, fg: "subtle" }) : null] })) : null] }));
+});

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

@@ -0,0 +1,50 @@
+import type { BoxProps, RenderOutput } from '@textui/core';
+import type { Block } from '../blocks.js';
+/**
+ * The conversation, as blocks in a feed.
+ *
+ * There is no scrolling in this file. `Feed` owns the viewport, the cursor and
+ * the tail it follows, because none of that is about chat: a transcript, an
+ * activity stream and a list of search results with snippets are the same
+ * problem, which is "entries that are not one line tall". What is left here is
+ * the only part that *is* about chat - which block draws as what.
+ */
+export interface ChatTranscriptProps extends BoxProps {
+    blocks: Block[];
+    expanded: Record<string, boolean>;
+    onToggle(id: string): void;
+    /** Which block the cursor is on. Held by the screen, like every other state. */
+    cursor?: number;
+    onCursor?(index: number): void;
+    /**
+     * What the find box is looking for.
+     *
+     * Passed down to be coloured where it appears, not to decide what is drawn:
+     * every block stays where it was and the ones holding the term light up, so
+     * a reader keeps the conversation around a hit instead of a filtered list
+     * of the lines that matched.
+     */
+    match?: string;
+    /**
+     * Keep the cursor in view rather than only when it moves.
+     *
+     * For the find box, which drives the cursor: its first hit is often the
+     * block the cursor is already on, and a feed that only scrolls on a change
+     * would leave that one off screen while the box counted it.
+     */
+    pinCursor?: boolean;
+    /**
+     * What this conversation is, as the first thing in it.
+     *
+     * Inside the scrolling region rather than pinned above it: a caption outside
+     * costs a row of the conversation on every screen for ever, so it has to
+     * earn each one - which is what forces it down to a line and then down to
+     * less than it was for. Here it costs nothing after the first screen.
+     *
+     * It is not a block. The cursor walks the conversation and there is nothing
+     * to do to a caption, so it sits ahead of the indices rather than in them.
+     */
+    head?: RenderOutput;
+    focusId?: string;
+}
+export declare const ChatTranscript: (props: ChatTranscriptProps) => RenderOutput;

package/dist/src/view/transcript.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
+import { defineComponent, useTheme } from '@textui/core';
+import { Feed, Row } from '@textui/widgets';
+import { ChatBubble, Gutter, ReasoningBlock, StreamingText } from './bubble.js';
+import { ToolCallRow } from './toolcall.js';
+export const ChatTranscript = defineComponent('ChatTranscript', (props) => {
+    const { blocks, expanded, onToggle, cursor, onCursor, head, match, pinCursor, focusId = 'chat.transcript', ...rest } = props;
+    // The caption is an entry the feed scrolls and the cursor does not visit,
+    // so every index the feed reports is one further along than the block it
+    // stands for. Converted here, once, rather than at each of the three
+    // places that would otherwise each have to remember.
+    const lead = head ? 1 : 0;
+    return (_jsxs(Feed, { focusId: focusId, 
+        // Page up from the composer means the conversation above it. There is
+        // nothing else on this screen those keys could be for, and taking the
+        // keyboard off the field to use them is what a reader is avoiding.
+        pageKeys: "always", ...(cursor !== undefined ? { selectedIndex: cursor + lead } : {}), ...(pinCursor ? { pinSelection: true } : {}), ...(onCursor ? { onSelect: (index) => onCursor(Math.max(0, index - lead)) } : {}), onActivate: (index) => {
+            const block = blocks[index - lead];
+            if (block)
+                onToggle(block.id);
+        }, ...rest, children: [head ?? null, blocks.map((block) => (_jsx(BlockView, { block: block, expanded: expanded[block.id] ?? false, active: cursor !== undefined && blocks[cursor]?.id === block.id, ...(match ? { match } : {}), onToggle: () => onToggle(block.id) }, block.id)))] }));
+});
+const BlockView = defineComponent('ChatBlockView', ({ block, expanded, active, match, onToggle }) => {
+    const theme = useTheme();
+    // Spread rather than passed, so a block with no search over it carries no
+    // extra prop and its text node is compared unchanged.
+    const hit = match ? { match } : {};
+    switch (block.kind) {
+        case 'said':
+            // The blank row is the turn boundary. A uniform gap between every block
+            // would space a paragraph from the sentence it belongs to just as much
+            // as it spaces one speaker from the next.
+            return (_jsx(ChatBubble, { speaker: "user", padding: [1, 0, 0, 0], children: _jsx("text", { content: block.text, wrap: "word", ...hit }) }));
+        case 'header':
+            return (_jsxs(Row, { gap: 1, padding: [1, 0, 0, 0], children: [_jsx("text", { content: theme.glyphs.bulletFilled, fg: block.state === 'running' ? 'accent' : 'muted' }), _jsx("text", { content: block.model ?? 'agent', bold: true, fg: "accent" }), block.settings ? _jsx("text", { content: block.settings, fg: "subtle" }) : null, _jsx("text", { content: block.meta, fg: "subtle", flex: 1 }), block.state === 'cancelled' ? _jsx("text", { content: "stopped", fg: "warning" }) : null, block.state === 'failed' ? _jsx("text", { content: "failed", fg: "danger" }) : null] }));
+        case 'prose':
+            return (_jsxs(Row, { gap: 1, children: [_jsx(Gutter, {}), _jsx(StreamingText, { content: block.content, streaming: block.streaming, flex: 1, ...hit })] }));
+        case 'reasoning':
+            return (_jsxs(Row, { gap: 1, children: [_jsx(Gutter, {}), _jsx(ReasoningBlock, { content: block.content, expanded: expanded, streaming: block.streaming, flex: 1, ...hit, ...(active ? { bg: 'selected' } : {}) })] }));
+        case 'notice':
+            return (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: theme.glyphs.info, fg: "info" }), _jsx("text", { content: block.content, fg: "muted", wrap: "word", flex: 1, ...hit })] }));
+        // Not a notice. A notice is the harness saying something in passing, and
+        // this is the turn stopping - so it takes the danger tone and says whether
+        // there is anything to carry on from.
+        case 'failure':
+            return (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: theme.glyphs.cross, fg: "danger" }), _jsx("text", { content: block.content, fg: "danger", wrap: "word", flex: 1, ...hit }), block.resumable ? _jsx("text", { content: "resumable", fg: "subtle" }) : null] }));
+        case 'tool':
+            // No gutter. A tool call is something the agent *did*, not something it
+            // said, so it sits at the turn's own left edge with a status glyph where
+            // the header's bullet is - rather than indented inside the rule as
+            // though it were a paragraph of the answer.
+            return _jsx(ToolCallRow, { call: block.call, expanded: expanded, active: active, onToggle: onToggle });
+        case 'queued':
+            // Not sent. It reads as a message unless it says so, and "I typed that
+            // and nothing happened" is the complaint that follows.
+            return (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: theme.glyphs.chevronRight, fg: active ? 'accent' : 'subtle' }), _jsx("text", { content: block.text, fg: "subtle", italic: true, wrap: "word", flex: 1, ...hit }), _jsx("text", { content: active ? 'enter drops it' : 'queued', fg: "warning" })] }));
+        default:
+            return null;
+    }
+});

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@softov/ahpc",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "A terminal client for the Agent Host Protocol: sessions, a streaming transcript, and interactive prompts",
+  "keywords": [
+    "ahp",
+    "agent-host-protocol",
+    "agent-host",
+    "agent",
+    "ai",
+    "protocol",
+    "json-rpc",
+    "websocket",
+    "cli",
+    "command-line",
+    "tui",
+    "terminal",
+    "client"
+  ],
+  "author": "Luiz Fernando Softov <lfs@softov.dev>",
+  "license": "MIT",
+  "homepage": "https://github.com/softov/ahpc#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/softov/ahpc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/softov/ahpc/issues"
+  },
+  "bin": {
+    "ahpc": "./dist/src/main.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "bench": "vitest bench --run",
+    "build": "tsc -p tsconfig.build.json",
+    "build:watch": "tsc -p tsconfig.json --watch",
+    "dev": "npm run build && node dist/src/main.js",
+    "dev:bun": "bun src/main.tsx",
+    "prepack": "tsc -p tsconfig.build.json",
+    "schema": "node tools/schema.mjs",
+    "start": "node dist/src/main.js",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "wire": "node tools/validate.mjs"
+  },
+  "dependencies": {
+    "@microsoft/agent-host-protocol": "^0.9.0",
+    "@textui/core": "^0.5.0",
+    "@textui/terminal": "^0.5.0",
+    "@textui/widgets": "^0.5.0"
+  },
+  "devDependencies": {
+    "@textui/testing": "^0.5.0",
+    "@types/node": "^22.10.2",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}