@yaag/extension 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaag/extension",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "publishConfig": {
     "access": "public"
   },
@@ -24,9 +24,9 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.84.0",
-    "@yaag/cli": "0.5.0",
-    "@yaag/runtime": "0.5.0",
-    "@yaag/tui": "0.5.0",
+    "@yaag/cli": "0.5.2",
+    "@yaag/runtime": "0.5.2",
+    "@yaag/tui": "0.5.2",
     "nanoid": "^6.0.1"
   },
   "peerDependencies": {

package/src/run-call-body.ts

@@ -0,0 +1,47 @@
+/**
+ * The text of one `yaag_run` call, as the transcript shows it: the call head,
+ * and under it either the Inline Program source or the hint that names the key
+ * which shows that source.
+ */
+import { keyText, type Theme } from "@earendil-works/pi-coding-agent";
+import { type ProgramParams, programExpansion, programLabel } from "./run-program-param.ts";
+
+/** What the call render needs: the call itself, its styling, and its state. */
+export interface CallBodyOptions {
+  readonly params: ProgramParams;
+  readonly theme: Theme;
+  /** True while pi shows the call expanded, where the source replaces the hint. */
+  readonly expanded: boolean;
+}
+
+/**
+ * The head alone, the head over the program source, or the head over the expand
+ * hint. A call with no source to show gets no hint, because the hint would
+ * promise an empty view.
+ */
+export function callBody(options: CallBodyOptions): string {
+  const { params, theme } = options;
+  const head =
+    theme.fg("toolTitle", theme.bold("yaag_run")) + theme.fg("muted", `(${programLabel(params)})`);
+  const expansion = programExpansion(params);
+  if (expansion === "") return head;
+  if (options.expanded) return `${head}\n${theme.fg("muted", expansion)}`;
+  const hint = expandHint(theme);
+  return hint === "" ? head : `${head}\n${hint}`;
+}
+
+/**
+ * The muted second line that tells the reader which key shows the program
+ * source. It reads the bound key, so a rebound keymap stays correct, and it is
+ * empty when the action has no key at all, because a hint that names no key
+ * tells the reader nothing.
+ *
+ * The caller's `Theme` styles the whole line `muted`. pi's own `keyHint` (pi
+ * `docs/extensions.md`, keybinding hints) styles the key `dim` and the
+ * description `muted` from a module-global theme instead, which a Host Session
+ * installs but a test does not.
+ */
+function expandHint(theme: Theme): string {
+  const key = keyText("app.tools.expand");
+  return key === "" ? "" : theme.fg("muted", `... (${key} to expand)`);
+}

package/src/run-tool.ts

@@ -4,6 +4,7 @@ import { Text } from "@earendil-works/pi-tui";
 import { initialSummary } from "@yaag/runtime";
 import { Type } from "typebox";
 import { type BackgroundStatus, createBackgroundStatus } from "./background-status.ts";
+import { callBody } from "./run-call-body.ts";
 import type { RunDetails } from "./run-details.ts";
 import { foregroundInline, foregroundResult, inlineAvailable } from "./run-foreground.ts";
 import { RunTreeComponent } from "./run-tree-component.ts";
@@ -15,12 +16,7 @@ import { type ProcessIdentity, readProcessStart } from "./process-liveness.ts";
 import { resolveProgramParams } from "./resume-source.ts";
 import type { ProgramTarget } from "./run-argv.ts";
 import { mintRunId } from "./run-id.ts";
-import {
-  confirmProgramTarget,
-  programExpansion,
-  programLabel,
-  programTarget,
-} from "./run-program-param.ts";
+import { confirmProgramTarget, programTarget } from "./run-program-param.ts";
 import type { RunLaunch } from "./run-record.ts";
 import type { LiveRun, RunRegistry, RunSettlement } from "./run-registry.ts";
 import { errorText, failure, observedSettlement } from "./run-settlement.ts";
@@ -137,11 +133,7 @@ export function createRunTool(deps: RunToolOptions): ToolDefinition<typeof param
     renderCall(params, theme, context) {
       const text =
         context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-      const head =
-        theme.fg("toolTitle", theme.bold("yaag_run")) +
-        theme.fg("muted", `(${programLabel(params)})`);
-      const body = context.expanded ? programExpansion(params) : "";
-      text.setText(body === "" ? head : `${head}\n${theme.fg("muted", body)}`);
+      text.setText(callBody({ params, theme, expanded: context.expanded }));
       return text;
     },
     renderResult(result, _options, _theme, context) {

package/src/run-tree-component.ts

@@ -37,12 +37,17 @@ export class RunTreeComponent {
     this.#state.ingest(details);
   }
 
-  /** Renders the four-region tree, plus the Result region once the Run settled. */
+  /**
+   * Renders the header, the tree and the Result region once the Run settled.
+   * It draws no key footer, and no ruled tree band when the Run spawned no
+   * Agent, because this surface takes no input.
+   */
   render(width: number): string[] {
     const id = this.#state.runId;
     return renderTree(this.#state, {
       now: this.#now(),
       width,
+      interactive: false,
       ...(id === undefined ? {} : { label: id }),
     }).map((line) => truncateToWidth(line, width));
   }