@esso0428/pi-subagents 0.15.16 → 0.16.0

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

@@ -1,50 +0,0 @@
-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/agent-widget.test.ts

@@ -1,161 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { AgentManager } from "../../src/agent-manager.js";
-import {
-  AgentWidget,
-  getWidgetLineBudget,
-  MAX_WIDGET_LINES,
-  type AgentActivity,
-  type Theme,
-} from "../../src/ui/agent-widget.js";
-import type { AgentRecord } from "../../src/types.js";
-
-const theme: Theme = {
-  fg: (_color, text) => text,
-  bold: (text) => text,
-};
-
-const managers: AgentManager[] = [];
-
-afterEach(() => {
-  for (const manager of managers.splice(0)) manager.dispose();
-});
-
-function makeRecord(overrides: Partial<AgentRecord> = {}): AgentRecord {
-  return {
-    id: "agent-1",
-    type: "Explore",
-    description: "Inspect the repository",
-    status: "completed",
-    toolUses: 0,
-    startedAt: 1_000,
-    completedAt: 2_000,
-    lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-    compactionCount: 0,
-    ...overrides,
-  };
-}
-
-function renderWidget(
-  records: AgentRecord[],
-  rows = 24,
-  activity = new Map<string, AgentActivity>(),
-  mode: "all" | "background" | "off" = "all",
-) {
-  const manager = { listAgents: () => records } as unknown as AgentManager;
-  const widget = new AgentWidget(manager, activity, () => mode);
-  const tui = { terminal: { columns: 200, rows } };
-  const render = () => (widget as any).renderWidget(tui, theme) as string[];
-  return { render, widget };
-}
-
-function createWidgetHarness(records: AgentRecord[]) {
-  const manager = { listAgents: () => records } as unknown as AgentManager;
-  let factory: ((tui: any, theme: Theme) => { render(): string[]; invalidate(): void }) | undefined;
-  const tui = {
-    terminal: { columns: 120, rows: 24 },
-    requestRender: vi.fn(),
-  };
-  const ui = {
-    setStatus: vi.fn(),
-    setWidget: vi.fn((_key: string, content: any) => { factory = content; }),
-  };
-  const widget = new AgentWidget(manager, new Map(), () => "all");
-  widget.setUICtx(ui);
-  widget.update();
-  factory?.(tui, theme).render();
-  tui.requestRender.mockClear();
-  return { records, tui, ui, widget, render: () => factory?.(tui, theme).render() ?? [] };
-}
-
-describe("AgentWidget live records", () => {
-  it("keeps restored history in the live widget and manager history", () => {
-    const manager = new AgentManager();
-    managers.push(manager);
-    manager.restoreCompleted([makeRecord({ id: "history", description: "restored history" })]);
-
-    const widget = new AgentWidget(manager, new Map(), () => "all");
-    const tui = { terminal: { columns: 120, rows: 24 } };
-
-    expect((widget as any).renderWidget(tui, theme).join("\n")).toContain("restored history");
-    expect(manager.listAgents().map(record => record.id)).toEqual(["history"]);
-    expect(manager.getRecord("history")).toBeDefined();
-  });
-
-  it("keeps a live completed record visible after markFinished", () => {
-    const record = makeRecord({ id: "live", description: "live completion" });
-    const { render, widget } = renderWidget([record]);
-
-    widget.markFinished(record.id);
-
-    expect(render().join("\n")).toContain("live completion");
-  });
-
-  it("normalizes multiline rows and bounds output by the responsive ceiling", () => {
-    const running = makeRecord({
-      id: "running",
-      status: "running",
-      completedAt: undefined,
-      description: "running\nsecond line",
-    });
-    const finished = makeRecord({
-      id: "finished",
-      description: "finished\nsecond line",
-    });
-    const extraFinished = Array.from({ length: 10 }, (_, i) => makeRecord({
-      id: `finished-${i}`,
-      description: `extra ${i}`,
-    }));
-    const activity = new Map<string, AgentActivity>([
-      [running.id, {
-        activeTools: new Map(),
-        toolUses: 0,
-        responseText: "activity\nsecond line",
-        turnCount: 1,
-        lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-      }],
-    ]);
-    const rows = 9;
-    const { render } = renderWidget([running, finished, ...extraFinished], rows, activity);
-    const lines = render();
-
-    expect(lines.every(line => !/[\r\n]/.test(line))).toBe(true);
-    expect(lines.length).toBeLessThanOrEqual(getWidgetLineBudget(rows));
-    expect(lines.length).toBeLessThanOrEqual(MAX_WIDGET_LINES);
-    expect(lines.join("\n")).toContain("running second line");
-    expect(lines.some(line => line.includes("more"))).toBe(true);
-  });
-
-  it("counts queued records in the overflow indicator on short terminals", () => {
-    const running = makeRecord({ id: "running", status: "running", completedAt: undefined });
-    const queued = makeRecord({ id: "queued", status: "queued", completedAt: undefined });
-    const { render } = renderWidget([running, queued], 6);
-
-    const output = render().join("\\n");
-    expect(output).toContain("+2 more");
-    expect(output).toContain("1 queued");
-  });
-
-  it("reserves editor space on short terminals while retaining the widget ceiling", () => {
-    expect(getWidgetLineBudget(9)).toBe(5);
-    expect(getWidgetLineBudget(100)).toBe(MAX_WIDGET_LINES);
-  });
-
-  it("does not request a render when a live snapshot is unchanged", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(10_000);
-    try {
-      const running = makeRecord({ id: "running", status: "running", completedAt: undefined });
-      const { widget, tui } = createWidgetHarness([running]);
-
-      widget.update();
-      expect(tui.requestRender).not.toHaveBeenCalled();
-
-      running.description = "changed description";
-      widget.update();
-      expect(tui.requestRender).toHaveBeenCalledTimes(1);
-      widget.dispose();
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-});

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

@@ -1,103 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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);
-  });
-});