@gavin-hu/my-pi-agent 0.17.0 → 0.19.0

package/extensions/session-bus/result.ts

@@ -0,0 +1,208 @@
+/**
+ * The `session` tool's transcript block: the expanded rows one section per entity
+ * group, and the one collapsed line a reader sees without expanding.
+ *
+ * The row grammar and the sanitization live in `rows.ts`; this module only decides
+ * which rows an action shows and how the failed ones read.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { sanitizeLine } from "../../lib/format.ts";
+import { SEPARATORS } from "../../lib/tui/glyphs.ts";
+import { TailResult, type TailResultInput, type TailSection } from "../../lib/tui/tool.ts";
+import { paint } from "../../lib/tui/tokens.ts";
+import { type BusRow, busRowLine, count, sessionRows } from "./rows.ts";
+import type { SessionDetails } from "./types.ts";
+
+/**
+ * The transcript block for an expanded `session` result: the shared tail block
+ * over the board's rows, one section per entity group.
+ */
+export class SessionResult implements Component {
+	private readonly view: TailResult<BusRow>;
+
+	constructor(input: TailResultInput<BusRow>, theme: Theme) {
+		this.view = new TailResult(input, theme);
+	}
+
+	/** Update in place so the transcript can reuse this component across renders. */
+	setInput(input: TailResultInput<BusRow>, theme: Theme): void {
+		this.view.setInput(input, theme);
+	}
+
+	invalidate(): void {
+		this.view.invalidate();
+	}
+
+	render(width: number): string[] {
+		return this.view.render(width);
+	}
+}
+
+/** One section of the expanded result. */
+function section(rows: BusRow[], label?: string): TailSection<BusRow> {
+	return { label, rows, more: 0, rowLine: busRowLine };
+}
+
+/**
+ * The expanded result rows for one action, in the order a reader expects: the
+ * board, the consumed mail, a conflict before the claim, released before
+ * not-owned. Returns `undefined` when the action has nothing to list.
+ */
+export function resultSections(details: SessionDetails): TailResultInput<BusRow> | undefined {
+	switch (details.action) {
+		case "status": {
+			const board = sessionRows(details.status);
+			const claims = board.flatMap((row) => row.claims);
+			const sections: TailSection<BusRow>[] = [];
+			if (board.length > 0) sections.push(section(board.map((row) => ({ kind: "session", row }))));
+			if (claims.length > 0) {
+				sections.push(
+					section(
+						claims.map((claim) => ({ kind: "claim", claim })),
+						"Claims",
+					),
+				);
+			}
+			return sections.length > 0 ? { kind: "sections", sections } : undefined;
+		}
+		case "inbox": {
+			const messages = details.messages ?? [];
+			if (messages.length === 0) return undefined;
+			return { kind: "sections", sections: [section(messages.map((message) => ({ kind: "message", message })))] };
+		}
+		case "claim": {
+			const conflicts = details.conflicts ?? [];
+			if (conflicts.length > 0) {
+				return {
+					kind: "sections",
+					sections: [
+						section(
+							conflicts.map((claim) => ({ kind: "claim", claim })),
+							"Conflicts",
+						),
+					],
+				};
+			}
+			const claimed = details.claimed ?? [];
+			if (claimed.length === 0) return undefined;
+			return {
+				kind: "sections",
+				sections: [
+					section(
+						claimed.map((label) => ({ kind: "result", label, tone: "ok" })),
+						"Claimed",
+					),
+				],
+			};
+		}
+		case "release": {
+			const released = details.released ?? [];
+			const notOwned = details.notOwned ?? [];
+			const sections: TailSection<BusRow>[] = [];
+			if (released.length > 0) {
+				sections.push(
+					section(
+						released.map((label) => ({ kind: "result", label, tone: "ok" })),
+						"Released",
+					),
+				);
+			}
+			if (notOwned.length > 0) {
+				sections.push(
+					section(
+						notOwned.map((label) => ({ kind: "result", label, tone: "warn" })),
+						"Not yours",
+					),
+				);
+			}
+			return sections.length > 0 ? { kind: "sections", sections } : undefined;
+		}
+		case "send": {
+			const delivered = details.delivered ?? [];
+			if (delivered.length === 0) return undefined;
+			return {
+				kind: "sections",
+				sections: [section(delivered.map((label) => ({ kind: "result", label, tone: "ok" })))],
+			};
+		}
+		case "join":
+			return undefined;
+	}
+}
+
+/**
+ * The collapsed result line: the one thing the user needs without expanding.
+ *
+ * A conflict or a path this session does not own is worth the warning role; a
+ * successful claim, release, or send is routine, so those stay calm.
+ */
+export function collapsedLine(theme: Theme, details: SessionDetails): string {
+	const sep = SEPARATORS.item;
+	switch (details.action) {
+		case "status": {
+			const board = sessionRows(details.status);
+			const unread = board.reduce((total, row) => total + row.session.unread, 0);
+			const claims = board.reduce((total, row) => total + row.claims.length, 0);
+			const cells = [count(board.length, "session")];
+			if (unread > 0) cells.push(`${unread} unread`);
+			cells.push(count(claims, "claim"));
+			const watching = details.status?.watching;
+			if (watching) cells.push(watching.wake ? "watch wake" : "watch on");
+			const line = paint(theme, "meta", cells.join(sep));
+			// A reader that has not joined is looking at a bus it is not on.
+			if (details.status?.onBus === false) {
+				return `${line}${paint(theme, "faint", sep)}${paint(theme, "warn", "not on the bus \u2014 session join puts you on it")}`;
+			}
+			return line;
+		}
+		case "send": {
+			const delivered = details.delivered ?? [];
+			if (delivered.length === 0) return paint(theme, "meta", "Delivered to nobody");
+			return paint(theme, "ok", `Delivered to ${delivered.map((label) => sanitizeLine(label)).join(", ")}`);
+		}
+		case "inbox": {
+			const messages = details.messages ?? [];
+			if (messages.length === 0) return paint(theme, "meta", "Inbox empty");
+			const senders = [...new Set(messages.map((message) => sanitizeLine(message.fromLabel)))];
+			return paint(theme, "meta", `${count(messages.length, "message")}${sep}${senders.join(", ")}`);
+		}
+		case "claim": {
+			const conflicts = details.conflicts ?? [];
+			if (conflicts.length > 0) {
+				const [first] = conflicts;
+				const more = conflicts.length - 1;
+				const path = first ? sanitizeLine(first.path) : "a path";
+				const owner = first ? sanitizeLine(first.ownerLabel) : "a peer";
+				return paint(
+					theme,
+					"warn",
+					`${count(conflicts.length, "conflict")}${sep}${path} held by ${owner}${more > 0 ? ` +${more} more` : ""}`,
+				);
+			}
+			const claimed = details.claimed ?? [];
+			if (claimed.length === 0) return paint(theme, "meta", "Claimed nothing");
+			return paint(theme, "ok", `Claimed ${claimed.map((path) => sanitizeLine(path)).join(", ")}`);
+		}
+		case "release": {
+			const released = details.released ?? [];
+			const notOwned = details.notOwned ?? [];
+			const parts: string[] = [];
+			if (released.length > 0)
+				parts.push(paint(theme, "ok", `Released ${released.map((path) => sanitizeLine(path)).join(", ")}`));
+			if (notOwned.length > 0) {
+				parts.push(paint(theme, "warn", `Not yours: ${notOwned.map((path) => sanitizeLine(path)).join(", ")}`));
+			}
+			return parts.length > 0 ? parts.join(paint(theme, "faint", sep)) : paint(theme, "meta", "Nothing to release");
+		}
+		case "join": {
+			const label = paint(theme, "ok", sanitizeLine(details.label ?? ""));
+			const state =
+				details.watching?.armed !== true
+					? paint(theme, "meta", "not listening")
+					: paint(theme, "meta", details.watching.wake === true ? "listening, wake" : "listening");
+			return `${label}${paint(theme, "faint", sep)}${state}`;
+		}
+	}
+}

package/extensions/session-bus/rows.ts

@@ -0,0 +1,171 @@
+/**
+ * The bus row grammar: the one place a session, a held path, or a message is
+ * turned into a line, shared by the `/sessions` board and the `session` tool
+ * block's expanded result.
+ *
+ * Every field came from another session's record, message, or claim, so it is
+ * sanitized here, at the boundary that reaches the terminal, and every row is
+ * clipped to the width it is given by `listRow`/`statusRow`.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { formatDuration, sanitizeLine } from "../../lib/format.ts";
+import { GLYPHS, SEPARATORS } from "../../lib/tui/glyphs.ts";
+import { listRow, statusRow } from "../../lib/tui/rows.ts";
+import type { TailRowLine } from "../../lib/tui/tool.ts";
+import { paint } from "../../lib/tui/tokens.ts";
+import { idSuffix } from "./format.ts";
+import type { BusMessage, ClaimRecord, SessionRecord, SessionStatus } from "./types.ts";
+
+/** Claim paths the focus block lists before it points at the pane. */
+const BLOCK_CLAIMS = 2;
+
+/** `1 claim`, `2 claims`. */
+export function count(n: number, noun: string): string {
+	return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+
+/** One session on the board, with the claims it holds. */
+export interface SessionRow {
+	session: SessionRecord & { unread: number };
+	/** Whether this row is the session reading the board. */
+	self: boolean;
+	claims: ClaimRecord[];
+}
+
+/** A row of the transcript's expanded result: one entity per action. */
+export type BusRow =
+	| { kind: "session"; row: SessionRow }
+	| { kind: "claim"; claim: Pick<ClaimRecord, "path" | "ownerLabel"> }
+	| { kind: "message"; message: BusMessage }
+	| { kind: "result"; label: string; tone: "ok" | "warn" };
+
+/** Label order by code unit, so a live re-sort is deterministic. */
+function byLabel(a: { label: string }, b: { label: string }): number {
+	return a.label < b.label ? -1 : a.label > b.label ? 1 : 0;
+}
+
+/**
+ * The board's rows: this session first, then peers by label, each with its own
+ * claims. A status without sessions (a failed read) is an empty board.
+ */
+export function sessionRows(status: SessionStatus | undefined): SessionRow[] {
+	if (!status) return [];
+	const rows = status.sessions.map((session) => ({
+		session,
+		self: session.id === status.me.id,
+		claims: status.claims
+			.filter((claim) => claim.owner === session.id)
+			.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0)),
+	}));
+	return rows.sort((a, b) => (a.self === b.self ? byLabel(a.session, b.session) : a.self ? -1 : 1));
+}
+
+/** One session row: the label, a `you` tag on this session, and its counts. */
+export function sessionRowLine(
+	row: SessionRow,
+	theme: Theme,
+	width: number,
+	options: { selected?: boolean; marker?: boolean } = {},
+): string {
+	const label = `${sanitizeLine(row.session.label)}${row.self ? " · you" : ""}`;
+	const counts = [`${row.session.unread} unread`];
+	if (row.claims.length > 0) counts.push(count(row.claims.length, "claim"));
+	return listRow(theme, width, {
+		selected: options.selected === true,
+		marker: options.marker !== false,
+		label,
+		labelRole: options.selected === true ? "accent" : "label",
+		trailing: counts.join(SEPARATORS.item),
+	});
+}
+
+/** One held path: the claim glyph, the path, and the session holding it. */
+export function claimRowLine(
+	claim: Pick<ClaimRecord, "path" | "ownerLabel">,
+	theme: Theme,
+	width: number,
+	options: { selected?: boolean; marker?: boolean; self?: boolean } = {},
+): string {
+	const owner = `${sanitizeLine(claim.ownerLabel)}${options.self === true ? " · you" : ""}`;
+	return statusRow(theme, width, {
+		selected: options.selected === true,
+		marker: options.marker !== false,
+		glyph: GLYPHS.target,
+		glyphRole: "info",
+		label: sanitizeLine(claim.path),
+		labelRole: options.selected === true ? "accent" : "label",
+		trailing: owner,
+	});
+}
+
+/** One message row: the sender and kind as meta trailing the text. */
+export function messageRowLine(
+	message: BusMessage,
+	theme: Theme,
+	width: number,
+	options: { selected?: boolean; marker?: boolean } = {},
+): string {
+	const glyph = message.kind === "event" ? GLYPHS.warn : message.kind === "ask" ? GLYPHS.unknown : GLYPHS.pending;
+	return statusRow(theme, width, {
+		selected: options.selected === true,
+		marker: options.marker !== false,
+		glyph,
+		glyphRole: message.kind === "event" ? "warn" : "info",
+		label: sanitizeLine(message.text),
+		labelRole: options.selected === true ? "accent" : "label",
+		trailing: `${sanitizeLine(message.fromLabel)}${SEPARATORS.item}${sanitizeLine(message.kind)}`,
+	});
+}
+
+/** The one row renderer the expanded transcript block uses. */
+export const busRowLine: TailRowLine<BusRow> = (row, width, theme) => {
+	switch (row.kind) {
+		case "session":
+			return sessionRowLine(row.row, theme, width, { marker: false });
+		case "claim":
+			return claimRowLine(row.claim, theme, width, { marker: false });
+		case "message":
+			return messageRowLine(row.message, theme, width, { marker: false });
+		case "result":
+			return statusRow(theme, width, {
+				marker: false,
+				glyph: row.tone === "ok" ? GLYPHS.check : GLYPHS.cross,
+				glyphRole: row.tone,
+				label: sanitizeLine(row.label),
+				trailing: "",
+			});
+	}
+};
+
+/** The summary cells: the counts a reader scans before the rows. */
+export function summaryCells(
+	theme: Theme,
+	rows: readonly SessionRow[],
+	watching: { armed: boolean; wake: boolean } | undefined,
+	onBus = true,
+): string[] {
+	const unread = rows.reduce((total, row) => total + row.session.unread, 0);
+	const claims = rows.reduce((total, row) => total + row.claims.length, 0);
+	const cells = [paint(theme, "meta", count(rows.length, "session"))];
+	if (unread > 0) cells.push(paint(theme, "label", `${unread} unread`));
+	cells.push(paint(theme, "meta", count(claims, "claim")));
+	if (watching) cells.push(paint(theme, "ok", watching.wake ? "watch wake" : "watch on"));
+	if (!onBus) cells.push(paint(theme, "warn", "not on the bus"));
+	return cells;
+}
+
+/** The focus block under the list: what the row does not already say. */
+export function sessionDetailBlock(row: SessionRow, now: number): string[] {
+	const lines = [`cwd: ${sanitizeLine(row.session.cwd)}`];
+	if (row.claims.length > 0) {
+		const shown = row.claims.slice(0, BLOCK_CLAIMS).map((claim) => sanitizeLine(claim.path));
+		const hidden = row.claims.length - shown.length;
+		lines.push(`claims: ${shown.join(", ")}${hidden > 0 ? ` +${hidden} more` : ""}`);
+	}
+	lines.push(
+		`mode: ${sanitizeLine(row.session.mode)}${SEPARATORS.item}id: ${idSuffix(row.session.id)}` +
+			`${SEPARATORS.item}last seen: ${formatDuration(Math.max(0, now - row.session.lastSeen))} ago`,
+	);
+	return lines;
+}