@esso0428/pi-subagents 0.15.5 → 0.15.7

package/test/agent-manager-history.test.ts

@@ -1,87 +1,88 @@
 import { afterEach, describe, expect, it } from "vitest";
 import { AgentManager } from "../src/agent-manager.js";
 
-type PersistedRecord = {
-  id: string;
-  type: string;
-  description: string;
-  status: string;
-  result?: unknown;
-  error?: unknown;
-  startedAt: number;
-  completedAt: number;
-  transcriptPath?: string;
-};
+const managers: AgentManager[] = [];
 
-function persisted(overrides: Partial<PersistedRecord> = {}): PersistedRecord {
+afterEach(() => {
+  for (const manager of managers.splice(0)) manager.dispose();
+});
+
+function makeManager(): AgentManager {
+  const manager = new AgentManager();
+  managers.push(manager);
+  return manager;
+}
+
+function record(overrides: Record<string, unknown> = {}) {
   return {
     id: "agent-1",
-    type: "general-purpose",
-    description: "history test",
+    type: "Explore",
+    description: "Inspect the repository",
     status: "completed",
-    result: "restored result",
-    startedAt: 100,
-    completedAt: 200,
+    result: "done",
+    toolUses: 2,
+    startedAt: 1_000,
+    completedAt: 2_000,
     ...overrides,
   };
 }
 
 describe("AgentManager.restoreCompleted", () => {
-  let manager: AgentManager | undefined;
+  it("restores all five terminal statuses without sessions", () => {
+    const manager = makeManager();
+    manager.restoreCompleted(["completed", "steered", "stopped", "aborted", "error"].map((status, i) =>
+      record({ id: `agent-${i}`, status }),
+    ));
 
-  afterEach(() => {
-    manager?.dispose();
-    manager = undefined;
+    expect(manager.listAgents()).toHaveLength(5);
+    for (const restored of manager.listAgents()) {
+      expect(["completed", "steered", "stopped", "aborted", "error"]).toContain(restored.status);
+      expect(restored.session).toBeUndefined();
+      expect(restored.abortController).toBeUndefined();
+      expect(restored.promise).toBeUndefined();
+      expect(restored.lifetimeUsage).toEqual({ input: 0, output: 0, cacheWrite: 0 });
+      expect(restored.compactionCount).toBe(0);
+    }
   });
 
-  it("restores terminal records without creating live runtime state", () => {
-    manager = new AgentManager();
-
+  it("ignores running, queued, and invalid records", () => {
+    const manager = makeManager();
     manager.restoreCompleted([
-      persisted(),
-      persisted({ id: "agent-error", status: "error", error: "failed", transcriptPath: ".pi-subagents/agent-transcripts/agent-error.jsonl" }),
-      persisted({ id: "agent-running", status: "running" }),
-      persisted({ id: "agent-queued", status: "queued" }),
-      persisted({ id: "agent-invalid", completedAt: Number.NaN }),
-      persisted({ id: "agent-unsafe", transcriptPath: ".pi-subagents/../private.jsonl" }),
+      record({ id: "running", status: "running" }),
+      record({ id: "queued", status: "queued" }),
+      { id: "invalid" },
     ]);
 
-    expect(manager.listAgents().map((record) => record.id).sort()).toEqual([
-      "agent-1",
-      "agent-error",
-    ]);
-    const restored = manager.getRecord("agent-1");
-    expect(restored).toMatchObject({
-      status: "completed",
-      result: "restored result",
-      toolUses: 0,
-      lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-      compactionCount: 0,
-      isBackground: true,
-      transcriptPath: undefined,
-    });
-    expect(restored?.session).toBeUndefined();
-    expect(restored?.promise).toBeUndefined();
-    expect(restored?.abortController).toBeUndefined();
+    expect(manager.listAgents()).toEqual([]);
   });
 
-  it("uses the newest branch entry when an id appears more than once", () => {
-    manager = new AgentManager();
-
+  it("keeps the last valid duplicate input", () => {
+    const manager = makeManager();
     manager.restoreCompleted([
-      persisted({ result: "old", completedAt: 200 }),
-      persisted({ result: "new", completedAt: 300 }),
+      record({ result: "first", startedAt: 1_000, completedAt: 1_100 }),
+      record({ result: "last", startedAt: 2_000, completedAt: 2_100 }),
     ]);
 
-    expect(manager.getRecord("agent-1")?.result).toBe("new");
+    expect(manager.getRecord("agent-1")?.result).toBe("last");
+    expect(manager.getRecord("agent-1")?.startedAt).toBe(2_000);
   });
 
-  it("does not overwrite a record already held by the manager", () => {
-    manager = new AgentManager();
+  it("does not replace a live record and rejects unsafe persisted data", () => {
+    const manager = makeManager();
+    // Exercise the public map through a restored terminal, then make it live
+    // without starting an LLM session.
+    manager.restoreCompleted([record({ id: "live", result: "original" })]);
+    const liveRecord = manager.getRecord("live")!;
+    liveRecord.status = "running";
 
-    manager.restoreCompleted([persisted({ result: "first" })]);
-    manager.restoreCompleted([persisted({ result: "second" })]);
+    manager.restoreCompleted([
+      record({ id: "live", result: "replacement" }),
+      record({ id: "bad-time", startedAt: Number.NaN }),
+      record({ id: "bad-path", transcriptPath: "../../outside.jsonl" }),
+    ]);
 
-    expect(manager.getRecord("agent-1")?.result).toBe("first");
+    expect(manager.getRecord("live")?.result).toBe("original");
+    expect(manager.getRecord("bad-time")).toBeUndefined();
+    expect(manager.getRecord("bad-path")).toBeUndefined();
   });
 });

package/test/agent-menu-history-navigation.test.ts

@@ -0,0 +1,86 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import extension from "../src/index.js";
+import { agentHistoryLocator } from "../src/agent-history.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+  for (const directory of tempDirectories.splice(0)) rmSync(directory, { recursive: true, force: true });
+});
+
+describe("/agents history navigation", () => {
+  it("returns to the Agents menu after closing a history viewer", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "pi-subagents-menu-test-"));
+    tempDirectories.push(cwd);
+    const transcript = ".pi-subagents/agent-transcripts/agent-1.jsonl";
+    mkdirSync(join(cwd, ".pi-subagents/agent-transcripts"), { recursive: true });
+    writeFileSync(join(cwd, transcript), JSON.stringify({ message: { role: "user", content: "hello" } }) + "\n");
+
+    const eventHandlers = new Map<string, Set<(...args: any[]) => any>>();
+    const events = {
+      on: (name: string, handler: (...args: any[]) => any) => {
+        const handlersForEvent = eventHandlers.get(name) ?? new Set<(...args: any[]) => any>();
+        handlersForEvent.add(handler);
+        eventHandlers.set(name, handlersForEvent);
+        return () => handlersForEvent.delete(handler);
+      },
+      emit: (name: string, ...args: any[]) => {
+        for (const handler of eventHandlers.get(name) ?? []) handler(...args);
+      },
+    };
+    const handlers = new Map<string, (...args: any[]) => any>();
+    let command: { handler: (_args: unknown, ctx: any) => Promise<void> } | undefined;
+    const pi: any = {
+      events,
+      registerMessageRenderer: () => {},
+      registerTool: () => {},
+      registerCommand: (_name: string, definition: typeof command) => { command = definition; },
+      on: (name: string, handler: (...args: any[]) => any) => { handlers.set(name, handler); },
+      appendEntry: () => {},
+      sendMessage: () => {},
+    };
+    extension(pi);
+
+    const titles: string[] = [];
+    let historySelections = 0;
+    const ui = {
+      notify: () => {},
+      setWidget: () => {},
+      setStatus: () => {},
+      onTerminalInput: () => () => {},
+      select: async (title: string, options: string[]) => {
+        titles.push(title);
+        if (title === "Agents" && titles.filter(item => item === "Agents").length === 1) {
+          return options.find(option => option.startsWith("Agent history ("));
+        }
+        if (title === "Agent history" && historySelections++ === 0) return options[0];
+        return undefined;
+      },
+      custom: async () => undefined,
+    };
+    const ctx = {
+      cwd,
+      ui,
+      sessionManager: {
+        getSessionId: () => undefined,
+        getBranch: () => [{
+          type: "custom",
+          customType: "subagents:record",
+          data: {
+            id: "agent-1", type: "Explore", description: "Inspect", status: "completed",
+            startedAt: 1, completedAt: 2, transcriptPath: agentHistoryLocator(cwd, join(cwd, transcript)),
+          },
+        }],
+      },
+    };
+
+    await handlers.get("session_start")?.({}, ctx);
+    await command?.handler({}, ctx);
+    await handlers.get("session_shutdown")?.();
+
+    expect(titles).toEqual(["Agents", "Agent history", "Agents"]);
+  });
+});

package/test/output-file-history.test.ts

@@ -0,0 +1,50 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { streamToOutputFile, writeInitialEntry } from "../src/output-file.js";
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("streamToOutputFile durable message snapshots", () => {
+  it("writes tool result details to both output and project history files", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "pi-subagents-output-test-"));
+    tempDirs.push(dir);
+    const outputPath = join(dir, "agent.output");
+    const historyPath = join(dir, "history.jsonl");
+    writeInitialEntry(outputPath, "agent-1", "run", dir);
+    writeInitialEntry(historyPath, "agent-1", "run", dir);
+
+    let listener: ((event: any) => void) | undefined;
+    const session = {
+      messages: [
+        { role: "user", content: "run" },
+        {
+          role: "toolResult",
+          toolCallId: "call-1",
+          toolName: "write",
+          content: [{ type: "text", text: "Successfully wrote to file.txt" }],
+          details: { diff: "+1 new", patch: "+new" },
+        },
+      ],
+      subscribe(next: (event: any) => void) {
+        listener = next;
+        return () => { listener = undefined; };
+      },
+    } as any;
+
+    const cleanup = streamToOutputFile(session, outputPath, "agent-1", dir, historyPath);
+    listener?.({ type: "turn_end" });
+    cleanup();
+
+    for (const path of [outputPath, historyPath]) {
+      const entries = (await readFile(path, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
+      expect(entries).toHaveLength(2);
+      expect(entries[1].message.details).toEqual({ diff: "+1 new", patch: "+new" });
+    }
+  });
+});

package/test/ui/conversation-blocks.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import { formatConversationMessages } from "../../src/ui/conversation-blocks.js";
+
+describe("formatConversationMessages", () => {
+  it("keeps markdown source for user and assistant blocks", () => {
+    const blocks = formatConversationMessages([
+      { role: "user", content: "# Ask\n\nUse `x`." },
+      { role: "assistant", content: [
+        { type: "text", text: "## Answer\n\n```ts\nconst x: number = 1;\n```" },
+      ] },
+    ] as any);
+
+    expect(blocks.filter((b) => b.kind === "text").map((b) => b.markdown)).toEqual([
+      "# Ask\n\nUse `x`.",
+      "## Answer\n\n```ts\nconst x: number = 1;\n```",
+    ]);
+  });
+
+  it("separates assistant tool calls and bounds tool results", () => {
+    const blocks = formatConversationMessages([
+      { role: "assistant", content: [
+        { type: "toolCall", name: "read", arguments: { path: "src/index.ts" } },
+      ] },
+      { role: "toolResult", toolName: "read", isError: false, content: [
+        { type: "text", text: "a".repeat(100) },
+      ] },
+    ] as any, { maxToolResultChars: 40 });
+
+    expect(blocks.some((b) => b.toolLine?.includes("read"))).toBe(true);
+    const result = blocks.find((b) => b.role === "tool" && b.fullText.includes("read"));
+    expect(result?.fullText.length).toBeLessThanOrEqual(40);
+  });
+
+  it("pairs tool results by id, then same-name source order, and preserves orphans", () => {
+    const blocks = formatConversationMessages([
+      { role: "assistant", content: [
+        { type: "toolCall", id: "call-read", name: "read", arguments: { path: "a.ts" } },
+        { type: "toolCall", id: "call-write", name: "write", arguments: { path: "b.ts", content: "new" } },
+      ] },
+      { role: "toolResult", toolCallId: "call-read", toolName: "read", isError: false, details: { source: "id" }, content: [{ type: "text", text: "read output" }] },
+      { role: "toolResult", toolName: "write", isError: true, details: { source: "name" }, content: [{ type: "text", text: "write failed" }] },
+      { role: "toolResult", toolCallId: "missing", toolName: "bash", isError: true, content: [{ type: "text", text: "orphan" }] },
+    ] as any);
+
+    const tools = blocks.filter((block) => block.kind === "tool");
+    expect(tools).toHaveLength(3);
+    expect(tools[0]?.toolCallId).toBe("call-read");
+    expect(tools[0]?.toolResult?.details).toEqual({ source: "id" });
+    expect(tools[1]?.toolCallId).toBe("call-write");
+    expect(tools[1]?.toolResult?.isError).toBe(true);
+    expect(tools[2]?.toolResult?.content).toEqual([{ type: "text", text: "orphan" }]);
+    expect(tools[2]?.fullText).toContain("orphan");
+  });
+
+  it("uses a stable synthetic id when a tool call omits its id", () => {
+    const blocks = formatConversationMessages([
+      { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "a.ts" } }] },
+      { role: "toolResult", toolName: "read", content: [{ type: "text", text: "ok" }] },
+    ] as any);
+
+    expect(blocks[0]?.toolCallId).toBe("message-0-tool-0");
+    expect(blocks[0]?.toolResult?.content).toEqual([{ type: "text", text: "ok" }]);
+  });
+
+  it("normalizes CRLF and bounds text with a deterministic truncation marker", () => {
+    const blocks = formatConversationMessages([
+      { role: "user", content: "one\r\ntwo\rthree\nfour" },
+    ] as any, { maxEntryChars: 12 });
+
+    expect(blocks[0]?.markdown).toBe("\n… [truncate");
+    expect(blocks[0]?.id).toBe("message-0");
+    expect(blocks[0]?.fullText.length).toBeLessThanOrEqual(12);
+  });
+
+  it("formats bash, images, summaries, and deterministic tool ids", () => {
+    const blocks = formatConversationMessages([
+      { role: "assistant", content: [
+        { type: "text", text: "answer" },
+        { type: "toolCall", name: "read", arguments: { path: "a.ts" } },
+        { type: "toolCall", name: "write", arguments: { path: "b.ts" } },
+      ] },
+      { role: "bashExecution", command: "echo hi", output: "hi" },
+      { role: "custom", customType: "note", content: [{ type: "image" }] },
+      { role: "compactionSummary", summary: "Earlier context" },
+    ] as any);
+
+    expect(blocks.map((block) => block.id)).toEqual([
+      "message-0", "message-0-tool-0", "message-0-tool-1", "message-1", "message-2", "message-3",
+    ]);
+    expect(blocks[1]?.toolLine).toContain("· read → a.ts");
+    expect(blocks[3]?.fullText).toContain("$ echo hi\nhi");
+    expect(blocks[4]?.markdown).toBe("[image]");
+    expect(blocks[5]?.role).toBe("meta");
+  });
+
+  it("skips unsupported or empty messages without throwing", () => {
+    expect(formatConversationMessages([
+      { role: "unknown", content: { not: "text" } },
+      { role: "user", content: [{ type: "thinking", thinking: "hidden" }] },
+      { role: "custom", display: false, content: "hidden" },
+    ] as any)).toEqual([]);
+  });
+});

package/test/ui/conversation-diff.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+  renderEditDiffResult,
+  renderWriteDiffResult,
+} from "../../src/ui/ccstyle/diff/diff-renderer.js";
+import { renderRichToolResult } from "../../src/ui/ccstyle/tool-result.js";
+import { DEFAULT_TOOL_DISPLAY_CONFIG } from "../../src/ui/ccstyle/diff/types.js";
+
+const theme = {
+  fg(color: string, text: string) {
+    return `<${color}>${text}</${color}>`;
+  },
+  bg(color: string, text: string) {
+    return `<bg:${color}>${text}</bg:${color}>`;
+  },
+  bold(text: string) {
+    return `<bold>${text}</bold>`;
+  },
+  getBgAnsi() {
+    return "";
+  },
+  getFgAnsi() {
+    return "";
+  },
+};
+
+const config = {
+  ...DEFAULT_TOOL_DISPLAY_CONFIG,
+  diffViewMode: "unified" as const,
+};
+
+describe("viewer-local ccstyle diff renderer", () => {
+  it("renders persisted write diff after the underlying file changes", () => {
+    const persisted = {
+      diff: "-1 old\n+1 new",
+      patch: "--- file.txt\n+++ file.txt\n@@ -1,1 +1,1 @@\n-old\n+new\n",
+    };
+
+    const first = renderWriteDiffResult(undefined, {
+      expanded: true,
+      filePath: "file.txt",
+      persistedDiff: persisted,
+    }, config, theme, "");
+    const second = renderWriteDiffResult(undefined, {
+      expanded: true,
+      filePath: "file.txt",
+      persistedDiff: persisted,
+    }, config, theme, "");
+
+    expect(second.render(100).join("\n")).toContain("new");
+    expect(second.render(100).join("\n")).toBe(first.render(100).join("\n"));
+  });
+
+  it("prefers persisted write diff over the current content fallback", () => {
+    const component = renderWriteDiffResult("later\n", {
+      expanded: true,
+      filePath: "file.txt",
+      previousContent: "old\n",
+      fileExistedBeforeWrite: true,
+      persistedDiff: { diff: "-1 old\n+1 new", patch: "--- file.txt\n+++ file.txt\n@@ -1,1 +1,1 @@\n-old\n+new\n" },
+    }, config, theme, "");
+
+    const rendered = component.render(100).join("\n");
+    expect(rendered).toContain("new");
+    expect(rendered).not.toContain("later");
+  });
+
+  it("returns an explicit unavailable row instead of an empty success card", () => {
+    const component = renderRichToolResult("write", {
+      content: [{ type: "text", text: "Successfully wrote" }],
+      details: { diffUnavailableReason: "durable diff exceeds limit" },
+    }, { expanded: true }, theme, { args: { path: "large.txt" } });
+
+    expect(component?.render(100).join("\n")).toContain("diff unavailable");
+  });
+
+  it("keeps edit diff and all output rows within the requested width", () => {
+    const component = renderEditDiffResult(
+      { diff: "-1 a very long removed line\n+1 a very long added line" },
+      { expanded: true, filePath: "file.ts" },
+      config,
+      theme,
+      "",
+    );
+
+    for (const width of [20, 40, 100]) {
+      expect(component.render(width).every((line) => visibleWidth(line) <= width)).toBe(true);
+    }
+  });
+});

package/test/ui/conversation-search.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import {
+  findConversationMatches,
+  highlightConversationLine,
+  nearestConversationMatchAfter,
+  nearestConversationMatchBefore,
+  stripAnsi,
+} from "../../src/ui/conversation-search.js";
+
+describe("conversation search helpers", () => {
+  it("uses smartcase substring matching", () => {
+    const lines = [{ plain: "const Answer = 42;" }, { plain: "answer again" }];
+    expect(findConversationMatches(lines, "answer")).toEqual([
+      { lineIdx: 0, col: 6, len: 6 },
+      { lineIdx: 1, col: 0, len: 6 },
+    ]);
+    expect(findConversationMatches(lines, "Answer")).toEqual([
+      { lineIdx: 0, col: 6, len: 6 },
+    ]);
+  });
+
+  it("highlights matches without consuming ANSI escape sequences", () => {
+    const styled = "\x1b[31mAnswer\x1b[39m";
+    const result = highlightConversationLine(
+      styled,
+      [{ lineIdx: 0, col: 0, len: 6, current: true }],
+      "<m>",
+      "<c>",
+      "</>",
+    );
+    expect(result).toContain("<c>");
+    expect(result).toContain("Answer");
+    expect(result).toContain("\x1b[31m");
+  });
+
+  it("strips CSI and OSC ANSI sequences", () => {
+    expect(stripAnsi("\x1b[31mred\x1b[39m")).toBe("red");
+    expect(stripAnsi("before\x1b]0;title\x07after")).toBe("beforeafter");
+    expect(stripAnsi("before\x1b]0;title\x1b\\after")).toBe("beforeafter");
+  });
+
+  it("wraps nearest-match navigation", () => {
+    const matches = [
+      { lineIdx: 2, col: 0, len: 3 },
+      { lineIdx: 5, col: 1, len: 3 },
+      { lineIdx: 9, col: 2, len: 3 },
+    ];
+    expect(nearestConversationMatchAfter(matches, 5)).toBe(1);
+    expect(nearestConversationMatchAfter(matches, 10)).toBe(0);
+    expect(nearestConversationMatchBefore(matches, 5)).toBe(1);
+    expect(nearestConversationMatchBefore(matches, 1)).toBe(2);
+    expect(nearestConversationMatchAfter([], 0)).toBe(-1);
+    expect(nearestConversationMatchBefore([], 0)).toBe(-1);
+  });
+});