@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/src/tui/action-hints.ts

@@ -1,69 +1,155 @@
 import { rawKeyHint, type MessageRenderer } from "@earendil-works/pi-coding-agent";
-import { MouseRegion, Text, stripTerminalSequences, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+import {
+  MouseRegion,
+  Text,
+  stripTerminalSequences,
+  truncateToWidth,
+  visibleWidth,
+  type Component,
+} from "@earendil-works/pi-tui";
 
 /** Native custom messages expose global expansion, but need their own per-message click state. */
 export function withMouseExpansion<T>(renderer: MessageRenderer<T>): MessageRenderer<T> {
-	const states = new WeakMap<object, { expanded: boolean; globalExpanded: boolean }>();
-	return (message, options, theme) => {
-		let state = states.get(message);
-		if (!state || state.globalExpanded !== options.expanded) {
-			state = { expanded: options.expanded, globalExpanded: options.expanded };
-			states.set(message, state);
-		}
-		const expansion = state;
-		const draw = () => renderer(message, { ...options, expanded: expansion.expanded }, theme);
-		let content = draw();
-		if (!content) return;
-		return new MouseRegion({ render: (width) => content?.render(width) ?? [], invalidate: () => content?.invalidate() }, (event) => {
-			if (event.type !== "click" || event.button !== "left") return;
-			expansion.expanded = !expansion.expanded;
-			content = draw();
-			return { handled: true };
-		});
-	};
+  const states = new WeakMap<object, { expanded: boolean; globalExpanded: boolean }>();
+  return (message, options, theme) => {
+    let state = states.get(message);
+    if (!state || state.globalExpanded !== options.expanded) {
+      state = { expanded: options.expanded, globalExpanded: options.expanded };
+      states.set(message, state);
+    }
+    const expansion = state;
+    const draw = () => renderer(message, { ...options, expanded: expansion.expanded }, theme);
+    let content = draw();
+    if (!content) {
+      return;
+    }
+    return new MouseRegion(
+      { render: (width) => content?.render(width) ?? [], invalidate: () => content?.invalidate() },
+      (event) => {
+        if (event.type !== "click" || event.button !== "left") {
+          return;
+        }
+        expansion.expanded = !expansion.expanded;
+        content = draw();
+        return { handled: true };
+      },
+    );
+  };
+}
+
+type ActionPart = string | { readonly text: string; readonly run: () => void };
+interface ActionRange {
+  readonly start: number;
+  readonly length: number;
+  readonly run: () => void;
+}
+interface ActionHit {
+  readonly row: number;
+  readonly start: number;
+  readonly end: number;
+  readonly run: () => void;
+}
+
+function actionSource(parts: readonly ActionPart[]): {
+  text: string;
+  source: string;
+  ranges: ActionRange[];
+} {
+  let text = "",
+    source = "";
+  const ranges: ActionRange[] = [];
+  for (const part of parts) {
+    const displayed =
+      typeof part === "string"
+        ? part
+        : part.text.replace(/\balt\+/gi, (key) =>
+            stripTerminalSequences(rawKeyHint(key, "")).trim(),
+          );
+    const plain = stripTerminalSequences(displayed).replace(/\t/g, "   ");
+    if (typeof part !== "string") {
+      ranges.push({ start: source.length, length: plain.length, run: part.run });
+    }
+    text += displayed;
+    source += plain;
+  }
+  return { text, source, ranges };
+}
+
+function lineHits(
+  shown: string,
+  from: number,
+  ranges: readonly ActionRange[],
+  row: number,
+): ActionHit[] {
+  const hits: ActionHit[] = [];
+  const to = from + shown.length;
+  for (const range of ranges) {
+    const start = Math.max(from, range.start),
+      end = Math.min(to, range.start + range.length);
+    if (start < end) {
+      hits.push({
+        row,
+        start: visibleWidth(shown.slice(0, start - from)),
+        end: visibleWidth(shown.slice(0, end - from)),
+        run: range.run,
+      });
+    }
+  }
+  return hits;
 }
 
 /** Declare action spans while building text; native Text owns wrapping and clipping. */
-export function actionHints(parts: Array<string | { text: string; run: () => void }>, style: (text: string) => string = (text) => text, ellipsis?: string): Component {
-	let text = "", source = "";
-	const ranges: Array<{ start: number; length: number; run: () => void }> = [];
-	for (const part of parts) {
-		const displayed = typeof part === "string" ? part : part.text.replace(/\balt\+/gi, (key) => stripTerminalSequences(rawKeyHint(key, "")).trim());
-		const plain = stripTerminalSequences(displayed).replace(/\t/g, "   ");
-		if (typeof part !== "string") ranges.push({ start: source.length, length: plain.length, run: part.run });
-		text += displayed;
-		source += plain;
-	}
-	text = style(text);
-	const content = new Text("", 0, 0);
-	let hits: Array<{ row: number; start: number; end: number; run: () => void }> = [];
-	return new MouseRegion({
-		invalidate() { content.invalidate(); hits = []; },
-		render(width) {
-			const clipped = ellipsis !== undefined && visibleWidth(text) > width;
-			content.setText(ellipsis === undefined ? text : truncateToWidth(text, width, ellipsis));
-			const lines = content.render(width);
-			hits = [];
-			let offset = 0;
-			for (const [row, line] of lines.entries()) {
-				const visible = stripTerminalSequences(line).trimEnd();
-				const shown = clipped ? visible.slice(0, Math.max(0, visible.length - ellipsis!.length)) : visible;
-				const from = source.indexOf(shown, offset);
-				if (!shown || from < 0) continue;
-				const to = from + shown.length;
-				for (const range of ranges) {
-					const start = Math.max(from, range.start), end = Math.min(to, range.start + range.length);
-					if (start < end) hits.push({ row, start: visibleWidth(shown.slice(0, start - from)), end: visibleWidth(shown.slice(0, end - from)), run: range.run });
-				}
-				offset = to;
-			}
-			return lines;
-		},
-	}, (event) => {
-		if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) return;
-		const hit = hits.find((hit) => hit.row === event.y && event.x >= hit.start && event.x < hit.end);
-		if (!hit) return;
-		if (event.type === "click") hit.run();
-		return { handled: true };
-	});
+export function actionHints(
+  parts: readonly ActionPart[],
+  style: (text: string) => string = (text) => text,
+  ellipsis?: string,
+): Component {
+  const { text: raw, source, ranges } = actionSource(parts);
+  const text = style(raw),
+    content = new Text("", 0, 0);
+  let hits: ActionHit[] = [];
+  return new MouseRegion(
+    {
+      invalidate() {
+        content.invalidate();
+        hits = [];
+      },
+      render(width) {
+        const clipped = ellipsis !== undefined && visibleWidth(text) > width;
+        content.setText(ellipsis === undefined ? text : truncateToWidth(text, width, ellipsis));
+        const lines = content.render(width);
+        hits = [];
+        let offset = 0;
+        for (const [row, line] of lines.entries()) {
+          const visible = stripTerminalSequences(line).trimEnd();
+          const shown = clipped
+            ? visible.slice(0, Math.max(0, visible.length - ellipsis.length))
+            : visible;
+          const from = source.indexOf(shown, offset);
+          if (shown.length === 0 || from < 0) {
+            continue;
+          }
+          hits.push(...lineHits(shown, from, ranges, row));
+          offset = from + shown.length;
+        }
+        return lines;
+      },
+    },
+    (event) => {
+      if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) {
+        return;
+      }
+      const hit = hits.find(
+        (candidate) =>
+          candidate.row === event.y && event.x >= candidate.start && event.x < candidate.end,
+      );
+      if (!hit) {
+        return;
+      }
+      if (event.type === "click") {
+        hit.run();
+      }
+      return { handled: true };
+    },
+  );
 }

package/src/tui/activity-lines.ts

@@ -0,0 +1,40 @@
+import { formatDuration, shortenPath } from "../shared/formatters.ts";
+import { hasText, nonemptyText } from "./text-values.ts";
+interface ActivityInput {
+  readonly currentTool?: string;
+  readonly currentToolStartedAt?: number;
+  readonly currentPath?: string;
+  readonly turnCount?: number;
+  readonly toolCount?: number;
+}
+function toolActivity(input: ActivityInput, now?: number): string | undefined {
+  if (!hasText(input.currentTool)) {
+    return;
+  }
+  if (input.currentToolStartedAt === undefined || now === undefined) {
+    return input.currentTool;
+  }
+  return `${input.currentTool} ${formatDuration(Math.max(0, now - input.currentToolStartedAt))}`;
+}
+/** Activity facts are shared by job, step and nested rows; each caller owns status/outcome policy. */
+export function activityFacts(input: ActivityInput, now?: number, counts = true): string[] {
+  const facts: string[] = [],
+    tool = toolActivity(input, now);
+  if (tool !== undefined) {
+    facts.push(tool);
+  }
+  if (hasText(input.currentPath)) {
+    facts.push(shortenPath(input.currentPath));
+  }
+  if (counts && input.turnCount !== undefined) {
+    facts.push(`${input.turnCount} turns`);
+  }
+  if (counts && input.toolCount !== undefined) {
+    facts.push(`${input.toolCount} tools`);
+  }
+  return facts;
+}
+export function joinActivity(facts: readonly string[], activity?: string, fallback = ""): string {
+  const prefix = hasText(activity) ? [activity] : [];
+  return nonemptyText([...prefix, ...facts].join(" · ")) ?? fallback;
+}

package/src/tui/agent-browser.ts

@@ -0,0 +1,354 @@
+import type {
+  SubagentState,
+  HistoryPageInput,
+  HistoryRunPage,
+  HistoryIndexHandle,
+  HistoryEntry,
+} from "../shared/types.ts";
+import { runHistoryIndex } from "../runs/shared/history-index.ts";
+import { indexedHistory, readableText, type AgentHistoryItem } from "./agent-history.ts";
+import type { AgentTask } from "./view-model.ts";
+import type { HistorySelection } from "./view-ports.ts";
+import type { AgentTaskStore } from "./task-store.ts";
+import type { ViewSession } from "./view-session.ts";
+import { hasText, errorText } from "./text-values.ts";
+interface BrowseRequest {
+  readonly generation: number;
+  readonly request: number;
+  readonly offset: number;
+  readonly text: string;
+}
+type Paging = Pick<HistoryPageInput, "before" | "after" | "cursor">;
+function boundary(
+  input: HistoryPageInput,
+): Pick<HistoryPageInput, "runId" | "index" | "terminalEntryId" | "endedAt"> {
+  return {
+    runId: input.runId,
+    index: input.index,
+    terminalEntryId: input.terminalEntryId,
+    endedAt: input.endedAt,
+  };
+}
+async function readMarker(
+  index: HistoryIndexHandle,
+  input: HistoryPageInput,
+): Promise<HistoryEntry | null | undefined> {
+  if (!hasText(input.readThrough) || input.readThrough.startsWith("result:")) {
+    return;
+  }
+  return index.entry({
+    ...boundary(input),
+    entryId: input.readThrough.replace(/:(?:\d+|error)$/, ""),
+  });
+}
+async function anchorPaging(
+  index: HistoryIndexHandle,
+  input: HistoryPageInput,
+  anchor: string | null | undefined,
+  marker: HistoryEntry | null | undefined,
+): Promise<Paging | undefined> {
+  if (anchor === null) {
+    return { after: 0 };
+  }
+  if (!hasText(anchor) || anchor.startsWith("result:")) {
+    return;
+  }
+  const entry =
+    anchor === input.readThrough
+      ? marker
+      : await index.entry({ ...boundary(input), entryId: anchor.replace(/:(?:\d+|error)$/, "") });
+  return entry ? { after: Math.max(0, entry.sequence - 1) } : undefined;
+}
+
+async function selectedHistory(
+  index: HistoryIndexHandle,
+  input: HistoryPageInput,
+  paging: Paging,
+  anchor: string | null | undefined,
+): Promise<Omit<HistorySelection, "isCurrent">> {
+  const marker = await readMarker(index, input),
+    selectedPaging = (await anchorPaging(index, input, anchor, marker)) ?? paging;
+  const result = await indexedHistory(index, { ...input, limit: 100, ...selectedPaging });
+  const latestPage =
+    selectedPaging.after !== undefined
+      ? !result.page.hasMore
+      : selectedPaging.before === undefined && selectedPaging.cursor === undefined;
+  const unreadStart =
+    input.readThrough === null || input.readThrough === undefined ? -1 : undefined;
+  return { ...result, latestPage, readThroughSequence: marker?.sequence ?? unreadStart };
+}
+function sameHistoryBoundary(a: HistoryPageInput, b: HistoryPageInput): boolean {
+  return (
+    a.runId === b.runId &&
+    a.index === b.index &&
+    a.leaf === b.leaf &&
+    a.terminalEntryId === b.terminalEntryId &&
+    a.endedAt === b.endedAt
+  );
+}
+/** Browse requests own paging, subscriptions and stale-observation guards, never execution authority. */
+export class AgentBrowser {
+  private refreshPromise?: Promise<void>;
+  private indexUnsubscribe?: () => void;
+  private listRequest = 0;
+  private appliedListRequest = -1;
+  private filter = "";
+  private offset = 0;
+  listPage?: HistoryRunPage;
+  listLoading = false;
+  listError?: string;
+  private readonly state: SubagentState;
+  private readonly store: AgentTaskStore;
+  private readonly session: ViewSession;
+  private readonly notify: () => void;
+  constructor(
+    state: SubagentState,
+    store: AgentTaskStore,
+    session: ViewSession,
+    notify: () => void,
+  ) {
+    this.state = state;
+    this.store = store;
+    this.session = session;
+    this.notify = notify;
+  }
+  get listFilter(): string {
+    return this.filter;
+  }
+  get listPending(): boolean {
+    return !this.listPage || this.appliedListRequest !== this.listRequest;
+  }
+  private active(snapshot: BrowseRequest): boolean {
+    return this.session.live(snapshot.generation) && snapshot.request === this.listRequest;
+  }
+  private wake(): void {
+    this.refresh().catch((error: unknown) => {
+      if (this.session.live()) {
+        this.listError = errorText(error);
+        this.notify();
+      }
+    });
+  }
+  refresh(browse = false): Promise<void> {
+    if (!this.session.live()) {
+      return Promise.resolve();
+    }
+    if (!browse && (this.state.ownedRuns?.size ?? 0) === 0 && !this.state.historyIndex) {
+      return Promise.resolve();
+    }
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    const snapshot = {
+      generation: this.session.generation,
+      request: this.listRequest,
+      offset: this.offset,
+      text: this.filter,
+    };
+    this.listLoading = this.listPending;
+    this.refreshPromise = this.refreshPage(snapshot);
+    return this.refreshPromise;
+  }
+  private async refreshPage(snapshot: BrowseRequest): Promise<void> {
+    try {
+      const index = await runHistoryIndex(this.state);
+      if (!this.session.live(snapshot.generation)) {
+        return;
+      }
+      this.indexUnsubscribe ??= index.onChanged(() => this.wake());
+      const page = await index.listRuns({
+        offset: snapshot.offset,
+        limit: 50,
+        text: hasText(snapshot.text) ? snapshot.text : undefined,
+        sort: "attention",
+        latestTasksOnly: true,
+      });
+      const dock =
+        hasText(snapshot.text) || snapshot.offset !== 0
+          ? await index.listRuns({ limit: 50, sort: "attention", latestTasksOnly: true })
+          : page;
+      if (!this.active(snapshot)) {
+        return;
+      }
+      this.applyLists(page, dock, snapshot);
+      await this.observeMetadata(index, snapshot);
+    } catch (error) {
+      if (this.active(snapshot)) {
+        this.listError = `Agents history unavailable: ${errorText(error)}. Retry (F5).`;
+      }
+    } finally {
+      this.finishRefresh(snapshot);
+    }
+  }
+  private applyLists(page: HistoryRunPage, dock: HistoryRunPage, snapshot: BrowseRequest): void {
+    this.listPage = page;
+    this.appliedListRequest = snapshot.request;
+    this.listError = undefined;
+    this.store.browsePage(page.rows);
+    this.store.dockPage(dock.rows);
+  }
+  private shouldObserve(task: Readonly<AgentTask>): boolean {
+    const visit = this.store.visits.get(task.key);
+    if (!visit || task.child.identityUnavailable === true) {
+      return false;
+    }
+    const idle =
+      task.child.state !== "live" &&
+      !task.question &&
+      task.key !== this.store.selectedKey &&
+      task.key !== this.store.pinned;
+    return !idle || visit.outbox.length > 0 || task.metadataAt !== task.run.updatedAt;
+  }
+  private async observeMetadata(index: HistoryIndexHandle, snapshot: BrowseRequest): Promise<void> {
+    const markers = new Map(
+      [...this.store.tasks, ...this.store.dockTasks].map((task) => [task.key, task]),
+    );
+    for (const task of markers.values()) {
+      if (!this.shouldObserve(task)) {
+        continue;
+      }
+      // Each observation applies before the next bounded query; owner/read markers may change at its await.
+      // oxlint-disable-next-line no-await-in-loop
+      await this.observeTask(index, task, snapshot);
+      if (!this.active(snapshot)) {
+        return;
+      }
+    }
+  }
+  private async observeTask(
+    index: HistoryIndexHandle,
+    task: Readonly<AgentTask>,
+    snapshot: BrowseRequest,
+  ): Promise<void> {
+    try {
+      const page = await index.historyPage({ ...this.store.historyInput(task), limit: 1 });
+      if (!this.active(snapshot)) {
+        return;
+      }
+      this.store.applyMetadata(task.key, page);
+    } catch (error) {
+      if (this.active(snapshot)) {
+        this.store.metadataUnavailable(
+          task.key,
+          `Conversation metadata unavailable: ${errorText(error)}`,
+        );
+      }
+    }
+  }
+  private finishRefresh(snapshot: BrowseRequest): void {
+    if (!this.session.live(snapshot.generation)) {
+      return;
+    }
+    this.listLoading = false;
+    this.refreshPromise = undefined;
+    this.notify();
+    if (snapshot.request !== this.listRequest) {
+      this.wake();
+    }
+  }
+  filterTasks(text: string): void {
+    if (text === this.filter) {
+      return;
+    }
+    this.filter = text.slice(0, 256);
+    this.offset = 0;
+    this.listRequest++;
+    this.store.retainSelected();
+    this.wake();
+  }
+  pageTasks(direction: "earlier" | "later"): void {
+    const next = direction === "later" ? this.listPage?.nextOffset : Math.max(0, this.offset - 50);
+    if (next === undefined || next === this.offset) {
+      return;
+    }
+    this.offset = next;
+    this.listRequest++;
+    this.wake();
+  }
+  async retry(key?: string): Promise<void> {
+    const generation = this.session.generation;
+    try {
+      const index = await runHistoryIndex(this.state, true);
+      await index.refresh(hasText(key) ? this.store.task(key)?.run.runId : undefined);
+    } catch (error) {
+      if (this.session.live(generation)) {
+        this.listError = `History refresh unavailable: ${errorText(error)}`;
+      }
+    }
+    if (this.session.live(generation)) {
+      await this.refresh();
+    }
+  }
+  async historyPage(
+    key: string,
+    paging: Paging = {},
+    anchor?: string | null,
+  ): Promise<HistorySelection | undefined> {
+    const task = this.store.task(key),
+      generation = this.session.generation;
+    if (!task || !this.session.live() || task.child.identityUnavailable === true) {
+      return;
+    }
+    const published = task.page,
+      source = task.historySource;
+    const sessionFile = task.child.sessionFile,
+      childState = task.child.state;
+    const input = this.store.historyInput(task),
+      index = await runHistoryIndex(this.state);
+    const isCurrent = (): boolean => {
+      const current = this.store.task(key);
+      if (
+        !this.session.live(generation) ||
+        this.state.historyIndex !== index ||
+        index.failure ||
+        !current ||
+        current.child.identityUnavailable === true ||
+        current.page !== published ||
+        current.historySource !== source ||
+        current.child.sessionFile !== sessionFile ||
+        current.child.state !== childState
+      ) {
+        return false;
+      }
+      return sameHistoryBoundary(this.store.historyInput(current), input);
+    };
+    const result = await selectedHistory(index, input, paging, anchor);
+    if (!this.session.live(generation) || this.store.task(key)?.run.runId !== task.run.runId) {
+      return;
+    }
+    return { ...result, isCurrent };
+  }
+  async savedResult(key: string, id: string): Promise<AgentHistoryItem> {
+    const task = this.store.task(key),
+      generation = this.session.generation;
+    if (!task || !this.session.live()) {
+      throw new Error("The owning session is no longer available.");
+    }
+    const index = await runHistoryIndex(this.state),
+      result = await index.result({ runId: task.run.runId, index: task.child.index });
+    if (!this.session.live(generation) || this.store.task(key)?.run.runId !== task.run.runId) {
+      throw new Error("The selected attempt changed; choose the report again.");
+    }
+    if (!result) {
+      throw new Error("The selected saved report is unavailable.");
+    }
+    return {
+      id,
+      kind: "assistant",
+      title: "Saved result",
+      text: readableText(result.text),
+      timestamp: result.timestamp,
+    };
+  }
+  dispose(): void {
+    this.indexUnsubscribe?.();
+    this.indexUnsubscribe = undefined;
+    this.refreshPromise = undefined;
+    this.listRequest++;
+    this.listPage = undefined;
+    this.listError = undefined;
+    this.listLoading = false;
+    this.offset = 0;
+    this.filter = "";
+  }
+}