@d3ara1n/pi-subagent 1.7.1 → 2.1.0

package/src/utils.test.ts

@@ -41,7 +41,9 @@ import {
   createThrottler,
   terminalResultLine,
   buildDisplayItems,
+  completionNoticeLines,
   formatToolCall,
+  briefFilesUsed,
 } from "./utils.ts";
 import type { ActivityEntry, SubagentResult, SubagentRole } from "./types.ts";
 
@@ -436,6 +438,60 @@ describe("terminalResultLine", () => {
   });
 });
 
+// ── completionNoticeLines: background-run completion notice card ──
+describe("completionNoticeLines", () => {
+  // Marker fakes so assertions can see both text and color placement.
+  const fg = (color: string, text: string) => `<${color}>${text}</${color}>`;
+  const bold = (text: string) => `*${text}*`;
+
+  test("header: bracket label + id (role) + plain-text outcome", () => {
+    assert.deepEqual(
+      completionNoticeLines({ id: "sub-3", role: "worker", outcome: "finished" }, fg, bold),
+      [
+        "<customMessageLabel>*[subagent]*</customMessageLabel> " +
+          "<customMessageText>sub-3 (worker)</customMessageText> " +
+          "<customMessageText>finished</customMessageText>",
+      ],
+    );
+  });
+
+  test("failed colors the outcome error-red, cancelled warning-yellow", () => {
+    const failed = completionNoticeLines({ id: "sub-1", role: "x", outcome: "failed" }, fg, bold)[0];
+    assert.ok(failed.includes("<error>failed</error>"));
+    const cancelled = completionNoticeLines(
+      { id: "sub-1", role: "x", outcome: "cancelled" },
+      fg,
+      bold,
+    )[0];
+    assert.ok(cancelled.includes("<warning>cancelled</warning>"));
+  });
+
+  test("task preview on its own line without a prefix, newlines flattened", () => {
+    const lines = completionNoticeLines(
+      {
+        id: "sub-2",
+        role: "explorer",
+        outcome: "finished",
+        task: "Map the routing\nstructure",
+      },
+      fg,
+      bold,
+    );
+    assert.deepEqual(lines[1], "<dim>Map the routing structure</dim>");
+  });
+
+  test("whitespace-only task: header-only notice", () => {
+    assert.deepEqual(
+      completionNoticeLines(
+        { id: "sub-4", role: "worker", outcome: "finished", task: "  " },
+        fg,
+        bold,
+      ).length,
+      1,
+    );
+  });
+});
+
 // ── formatToolCall: single-line guarantee for TUI rows ──
 describe("formatToolCall newline sanitization", () => {
   const id = (_color: string, text: string) => text;
@@ -749,3 +805,51 @@ describe("streamed-text activity entries", () => {
     );
   });
 });
+
+describe("briefFilesUsed", () => {
+  const call = (toolName: string, args: Record<string, any>): ActivityEntry => ({
+    kind: "toolCall",
+    id: `tc-${toolName}`,
+    status: "done",
+    toolName,
+    args,
+  });
+  const F1 = "/Users/x/proj/src/a.ts";
+  const F2 = "/Users/x/proj/docs/guide.md";
+
+  test("marks a file matched by an exact-path arg", () => {
+    const used = briefFilesUsed([F1, F2], [call("read", { file_path: F1 })]);
+    assert.equal(used.get(F1), true);
+    assert.equal(used.get(F2), false);
+  });
+
+  test("marks a file referenced inside a bash command", () => {
+    const used = briefFilesUsed([F1], [call("bash", { command: `cat ${F1} | head -5` })]);
+    assert.equal(used.get(F1), true);
+  });
+
+  test("marks a file the child addressed by relative path", () => {
+    const used = briefFilesUsed([F1], [call("edit", { file_path: "src/a.ts" })]);
+    assert.equal(used.get(F1), true);
+  });
+
+  test("ignores short separator-less values — no false positives", () => {
+    const used = briefFilesUsed([F1], [call("grep", { pattern: "a.ts" })]);
+    assert.equal(used.get(F1), false);
+  });
+
+  test("collects strings from nested args one level deep", () => {
+    const used = briefFilesUsed([F1], [
+      call("edit", { edits: [{ oldText: "x", path: F1 }] }),
+    ]);
+    assert.equal(used.get(F1), true);
+  });
+
+  test("skips non-toolCall entries and empty file lists", () => {
+    assert.equal(briefFilesUsed(undefined, [call("read", { file_path: F1 })]).size, 0);
+    const used = briefFilesUsed([F1], [
+      { kind: "text", id: "text-0", status: "done", text: "hi" },
+    ]);
+    assert.equal(used.get(F1), false);
+  });
+});

package/src/utils.ts

@@ -9,6 +9,7 @@ import type { Component } from "@earendil-works/pi-tui";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import type {
   ActivityEntry,
+  CompletionNoticeDetails,
   FallbackFrom,
   RunState,
   SubagentDetails,
@@ -269,6 +270,56 @@ export function renderDisplayItems(
   return text.trimEnd();
 }
 
+// ── Brief page (subagent:view detail view) ─────────────────────
+
+/** Collect string values from a tool call's args, up to a small nesting depth. */
+function argStrings(args: Record<string, any> | undefined): string[] {
+  const out: string[] = [];
+  const walk = (v: unknown, depth: number): void => {
+    if (typeof v === "string") {
+      out.push(v);
+    } else if (depth > 0 && Array.isArray(v)) {
+      for (const item of v) walk(item, depth - 1);
+    } else if (depth > 0 && v && typeof v === "object") {
+      for (const item of Object.values(v)) walk(item, depth - 1);
+    }
+  };
+  walk(args, 3);
+  return out;
+}
+
+/** Arg values shorter than this (and without a separator) are ignored as path candidates. */
+const PATH_MATCH_MIN = 5;
+
+/**
+ * Cross-annotation for the brief page's file list: for each delegate
+ * reference file, did any tool call in the activity log touch it? Heuristic
+ * string match — a hit is either an arg containing the full path (absolute
+ * use, bash references) or the file path ending with the arg (the child
+ * using a relative form). Short separator-less values never match, so plain
+ * query strings cannot false-positive.
+ */
+export function briefFilesUsed(
+  files: string[] | undefined,
+  activityLog: ActivityEntry[],
+): Map<string, boolean> {
+  const used = new Map<string, boolean>((files ?? []).map((f) => [f, false]));
+  if (used.size === 0) return used;
+  for (const entry of activityLog) {
+    if (entry.kind !== "toolCall") continue;
+    for (const v of argStrings(entry.args)) {
+      if (v.length < PATH_MATCH_MIN) continue;
+      for (const [file, hit] of used) {
+        if (hit) continue;
+        if (v.includes(file) || (v.includes("/") && file.endsWith(v))) {
+          used.set(file, true);
+        }
+      }
+    }
+  }
+  return used;
+}
+
 // ── Shared result-view composition ─────────────────────────────
 // Used by the foreground delegate row (./render.ts) and the background
 // wait/check rows (./render-async.ts) so every view renders the same
@@ -286,6 +337,40 @@ export function taskPreview(task: string): string {
   return firstLine.length > 70 ? `${firstLine.slice(0, 70)}...` : firstLine;
 }
 
+/**
+ * Lines of the background-run completion notice. Bracket label + id/role +
+ * outcome on the header line, the bare task preview beneath (dim). Pure
+ * notification: the result itself never appears here — it surfaces through
+ * subagent_check (model) or /subagent:status (user). The renderer truncates
+ * each line to the terminal width independently, so the header never falls
+ * off the right edge.
+ *
+ * Visual family: the [compaction] system-notice card (bracket label, purple
+ * box), deliberately NOT the tool-row family — no tool-title prefix, no
+ * status icons. Signals "system event", not model behavior.
+ */
+export function completionNoticeLines(
+  details: CompletionNoticeDetails,
+  fg: (color: string, text: string) => string,
+  bold: (text: string) => string,
+): string[] {
+  // Intentional stops keep the plain text color; only real failures go red
+  // (cancelled keeps warning yellow, mirroring result-line semantics).
+  const outcomeColor =
+    details.outcome === "failed" ? "error" : details.outcome === "cancelled" ? "warning" : "customMessageText";
+  const header =
+    fg("customMessageLabel", bold("[subagent]")) +
+    ` ${fg("customMessageText", `${details.id} (${details.role})`)} ` +
+    fg(outcomeColor, details.outcome);
+
+  const lines = [header];
+  const task = oneLine(details.task ?? "").trim();
+  if (task) {
+    lines.push(fg("dim", task));
+  }
+  return lines;
+}
+
 /**
  * Width-aware collapsed-view component: renders each line truncated with "…"
  * to the actual viewport width (never wraps), padded full-width like Text(0,0).