@yaag/tui 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaag/tui",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "publishConfig": {
     "access": "public"
   },
@@ -19,6 +19,6 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.84.0",
-    "@yaag/runtime": "0.10.0"
+    "@yaag/runtime": "0.11.0"
   }
 }

package/src/tree/tree-agent-facts.ts

@@ -0,0 +1,66 @@
+import type { AgentInfo } from "@yaag/runtime";
+import {
+  costText,
+  durationText,
+  modelText,
+  sanitizeTerminalLine,
+  tokensText,
+} from "../text/index.ts";
+import type { AgentTimers } from "./agent-timers.ts";
+
+/** Everything one Agent row's facts are built from; `now` is already resolved. */
+export interface AgentFactsOptions {
+  readonly agent: AgentInfo;
+  readonly settled: number;
+  readonly timers: AgentTimers;
+  /** The Agent's Parent Link resolved to a row in this tree (`lineageOf`). */
+  readonly parentShown: boolean;
+}
+
+/**
+ * The Agent row's facts. The headline fact keeps the Agent's state and both
+ * timers in one string, because the compact and inline frames render only the
+ * first fact. Fork and compaction facts stay short so the row still fits a
+ * narrow pane.
+ */
+export function agentFacts(options: AgentFactsOptions): readonly string[] {
+  const { agent, settled, timers } = options;
+  const clocks = `active ${durationText(timers.activeMs)} · idle ${durationText(timers.idleMs)}`;
+  const facts: string[] = [];
+  if (agent.state === "asking") facts.push(`ask #${agent.askIndex + 1} · ${clocks}`);
+  else if (agent.state === "exited")
+    facts.push(`exited · ${settled} ask${settled === 1 ? "" : "s"} · ${clocks}`);
+  else facts.push(clocks);
+  facts.push(
+    `${costText(agent.cost, agent.incomplete)} · ${tokensText(agent.tokens?.total ?? null)}`,
+  );
+  if (agent.model !== null) facts.push(modelText(agent.model));
+  const last = agent.modelFallbacks.at(-1);
+  if (last !== undefined) {
+    facts.push(sanitizeTerminalLine(`fallback · ${last.failedModel} → ${last.resolvedModel}`));
+  }
+  const fork = forkFact(agent, options.parentShown);
+  if (fork !== null) facts.push(fork);
+  const compaction = compactionFact(agent);
+  if (compaction !== null) facts.push(compaction);
+  return facts;
+}
+
+/** Names the fork source only when its row is absent, so it is not repeated. */
+function forkFact(agent: AgentInfo, parentShown: boolean): string | null {
+  if (agent.origin !== "fork") return null;
+  if (parentShown || agent.parent === null) return "fork";
+  return sanitizeTerminalLine(`fork of ${agent.parent}`);
+}
+
+/**
+ * Compaction spend is never summed here: `agent_exit` already includes it
+ * (ADR-0043), so the row states the count and the context sizes only.
+ */
+function compactionFact(agent: AgentInfo): string | null {
+  if (agent.compactions <= 0) return null;
+  const count = `compacted ×${agent.compactions}`;
+  const last = agent.lastCompaction;
+  if (last === null || last.tokensBefore === null || last.tokensAfter === null) return count;
+  return `${count} · ${tokensText(last.tokensBefore)} → ${tokensText(last.tokensAfter)}`;
+}

package/src/tree/tree-model.ts

@@ -1,14 +1,8 @@
 import type { AgentInfo } from "@yaag/runtime";
-import {
-  activityText,
-  costText,
-  durationText,
-  modelText,
-  sanitizeTerminalLine,
-  tokensText,
-} from "../text/index.ts";
-import { type AgentTimers, agentTimers } from "./agent-timers.ts";
+import { activityText, durationText, modelText, sanitizeTerminalLine } from "../text/index.ts";
+import { agentTimers } from "./agent-timers.ts";
 import { type AskRow, askDwellMs } from "./ask-ledger.ts";
+import { agentFacts } from "./tree-agent-facts.ts";
 import { type Lineage, lineageOf } from "./tree-lineage.ts";
 import { graftNestedNodes } from "./tree-nested.ts";
 import type { TreeNode } from "./tree-node.ts";
@@ -36,33 +30,46 @@ export function buildTree(state: TreeState, options: TreeModelOptions): readonly
     if (agent !== undefined) known.set(name, agent);
   }
   const lineage = lineageOf([...known.keys()], (name) => state.parentLinkOf(name));
-  return subtrees(state, lineage.roots, known, lineage, options.now);
+  return subtrees({ state, known, lineage, now: options.now }, lineage.roots, false);
+}
+
+/** What every level of the recursion shares; only the names and depth change. */
+interface BuildContext {
+  readonly state: TreeState;
+  readonly known: ReadonlyMap<string, AgentInfo>;
+  readonly lineage: Lineage;
+  readonly now: number;
 }
 
 function subtrees(
-  state: TreeState,
+  context: BuildContext,
   names: readonly string[],
-  known: ReadonlyMap<string, AgentInfo>,
-  lineage: Lineage,
-  now: number,
+  parentShown: boolean,
 ): readonly TreeNode[] {
   const nodes: TreeNode[] = [];
   for (const name of names) {
-    const agent = known.get(name);
+    const agent = context.known.get(name);
     if (agent === undefined) continue;
-    const children = subtrees(state, lineage.children(name), known, lineage, now);
-    nodes.push(agentNode(state, name, agent, now, children));
+    const children = subtrees(context, context.lineage.children(name), true);
+    nodes.push(agentNode(context, { name, agent, parentShown }, children));
   }
   return nodes;
 }
 
+/** The Agent this node is for, plus whether `lineageOf` gave its parent a row. */
+interface AgentSlot {
+  readonly name: string;
+  readonly agent: AgentInfo;
+  readonly parentShown: boolean;
+}
+
 function agentNode(
-  state: TreeState,
-  name: string,
-  agent: AgentInfo,
-  now: number,
+  context: BuildContext,
+  slot: AgentSlot,
   childAgents: readonly TreeNode[],
 ): TreeNode {
+  const { state, now } = context;
+  const { name, agent } = slot;
   const ledger = state.ledger(name);
   const nested = graftNestedNodes(name, agent.nodes, now);
   const gist = agent.activity === null ? null : activityText(agent.activity);
@@ -82,11 +89,12 @@ function agentNode(
     kind: "agent",
     label: sanitizeTerminalLine(name),
     state: agentState(agent),
-    facts: agentFacts(
+    facts: agentFacts({
       agent,
-      state.settledAsks(name),
-      agentTimers({ agent, ledger, spawnedAt: state.spawnedAt(name), now }),
-    ),
+      settled: state.settledAsks(name),
+      timers: agentTimers({ agent, ledger, spawnedAt: state.spawnedAt(name), now }),
+      parentShown: slot.parentShown,
+    }),
     children,
     activityGist: gist,
     startedAt: agent.stateChangedAt,
@@ -138,26 +146,3 @@ function agentState(agent: AgentInfo): TreeNode["state"] {
   if (agent.state === "exited") return "exited";
   return agent.state === "asking" ? "running" : "idle";
 }
-
-/**
- * The Agent row's facts. The headline fact keeps the Agent's state and both
- * timers in one string, because the compact and inline frames render only the
- * first fact.
- */
-function agentFacts(agent: AgentInfo, settled: number, timers: AgentTimers): readonly string[] {
-  const clocks = `active ${durationText(timers.activeMs)} · idle ${durationText(timers.idleMs)}`;
-  const facts: string[] = [];
-  if (agent.state === "asking") facts.push(`ask #${agent.askIndex + 1} · ${clocks}`);
-  else if (agent.state === "exited")
-    facts.push(`exited · ${settled} ask${settled === 1 ? "" : "s"} · ${clocks}`);
-  else facts.push(clocks);
-  facts.push(
-    `${costText(agent.cost, agent.incomplete)} · ${tokensText(agent.tokens?.total ?? null)}`,
-  );
-  if (agent.model !== null) facts.push(modelText(agent.model));
-  const last = agent.modelFallbacks.at(-1);
-  if (last !== undefined) {
-    facts.push(sanitizeTerminalLine(`fallback · ${last.failedModel} → ${last.resolvedModel}`));
-  }
-  return facts;
-}