@esso0428/pi-subagents 0.15.16 → 0.16.0

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

@@ -1,438 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { TuiMouseEvent } from "@earendil-works/pi-tui";
-import { ConversationViewer, createStaticConversationSource } from "../../src/ui/conversation-viewer.js";
-
-const theme = {
-  fg: (name: string, text: string) => name === "text" ? `\x1b[36m${text}\x1b[39m` : text,
-  bold: (text: string) => `\x1b[1m${text}\x1b[22m`,
-};
-
-function record(extra: Record<string, unknown> = {}): any {
-  return {
-    id: "agent-1",
-    type: "general-purpose",
-    description: "test agent",
-    status: "completed",
-    toolUses: 0,
-    startedAt: 0,
-    lifetimeUsage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    ...extra,
-  };
-}
-
-function tui() {
-  return {
-    terminal: { rows: 30 },
-    requestRender: vi.fn(),
-    stop: vi.fn(),
-    start: vi.fn(),
-  } as any;
-}
-
-function mouse(type: TuiMouseEvent["type"], y: number, overrides: Partial<TuiMouseEvent> = {}): TuiMouseEvent {
-  return {
-    type,
-    button: "left",
-    x: 2,
-    y,
-    screenX: 2,
-    screenY: y,
-    width: 120,
-    height: 30,
-    shift: false,
-    alt: false,
-    ctrl: false,
-    ...overrides,
-  };
-}
-
-// The test record has the default invocation row, so timeline line 0 is viewer row 4.
-function viewerY(timelineLine: number): number {
-  return 4 + timelineLine;
-}
-
-describe("ConversationViewer", () => {
-  it("renders assistant fenced code through the Markdown renderer", () => {
-    const ui = tui();
-    const viewer = new ConversationViewer(
-      ui,
-      createStaticConversationSource([
-        { role: "assistant", content: [{ type: "text", text: "```ts\nconst answer: number = 42;\n```" }] },
-      ] as any),
-      record(),
-      undefined,
-      theme,
-      vi.fn(),
-    );
-
-    const rendered = viewer.render(100).join("\n");
-    expect(rendered).toContain("answer");
-    expect(rendered).toMatch(/\x1b\[/);
-  });
-
-  it("toggles compact tool rows without changing the transcript", () => {
-    const ui = tui();
-    const viewer = new ConversationViewer(
-      ui,
-      createStaticConversationSource([
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "src/index.ts" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "contents" }] },
-      ] as any),
-      record(),
-      undefined,
-      theme,
-      vi.fn(),
-    );
-
-    expect(viewer.render(100).join("\n")).toContain("read");
-    viewer.handleInput("t");
-    expect(viewer.render(100).join("\n")).not.toContain("contents");
-    viewer.handleInput("t");
-    expect(viewer.render(100).join("\n")).toContain("contents");
-  });
-
-  it("shows pi-peek hints for live viewers and hides O in history", () => {
-    const live = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([{ role: "assistant", content: "live" }] as any),
-      record({ status: "running", session: {} }),
-      undefined,
-      theme,
-      vi.fn(),
-      vi.fn(),
-      undefined,
-      vi.fn(),
-      { pi: {} as any, ctx: {} as any, readOnly: false },
-    );
-    const liveFooter = live.render(120).join("\n");
-    expect(liveFooter).toContain("j/k scroll · J/K messages · [/] tools · w preview · g/G   t   M o O   /n N   q");
-    expect(liveFooter).toContain("e steer");
-    expect(liveFooter).toContain("x stop");
-    live.handleInput("e");
-    expect(live.render(120).join("\n")).toContain("Enter send");
-    live.handleInput("\x1b");
-
-    const history = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([{ role: "assistant", content: "history" }] as any),
-      record({ session: {} }),
-      undefined,
-      theme,
-      vi.fn(),
-      undefined,
-      undefined,
-      undefined,
-      { pi: {} as any, ctx: {} as any, readOnly: true },
-    );
-    const historyFooter = history.render(120).join("\n");
-    expect(historyFooter).toContain("j/k scroll · J/K messages · [/] tools · w preview · g/G   t   M o   /n N   q");
-    expect(historyFooter).not.toContain("M o O");
-  });
-
-  it("shows semantic role headers, effective invocation metadata, and the search row", () => {
-    const semanticTheme = {
-      fg: (name: string, text: string) => `<${name}>${text}</${name}>`,
-      bold: (text: string) => `<bold>${text}</bold>`,
-    };
-    const viewer = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([
-        { role: "user", content: "find model" },
-        { role: "assistant", content: [{ type: "text", text: "model found" }] },
-      ] as any),
-      record({ invocation: { effectiveModelName: "claude-sonnet", effectiveThinking: "high" } }),
-      undefined,
-      semanticTheme,
-      vi.fn(),
-    );
-
-    const initial = viewer.render(120).join("\n");
-    expect(initial).toContain("<userMessageText>USER</userMessageText>");
-    expect(initial).toContain("<accent>ASSISTANT</accent>");
-    expect(initial).toContain("model: claude-sonnet");
-    expect(initial).toContain("thinking: high");
-
-    viewer.handleInput("/");
-    const searchRow = viewer.render(120).join("\n");
-    expect(searchRow).toContain("<accent>/</accent>");
-    expect(searchRow).toContain("Enter apply · Esc cancel");
-    for (const character of "model") viewer.handleInput(character);
-    expect(viewer.render(120).join("\n")).toContain("model");
-  });
-
-  it("focuses and expands a bounded fallback tool card", () => {
-    const viewer = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "x" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "one\ntwo\nthree\nfour\nfive\nsix" }] },
-      ] as any),
-      record(),
-      undefined,
-      theme,
-      vi.fn(),
-    );
-
-    expect(viewer.render(120).join("\n")).not.toContain("six");
-    viewer.handleInput("\t");
-    viewer.handleInput("\r");
-    expect(viewer.render(120).join("\n")).toContain("six");
-  });
-
-  it("toggles mouse expansion only on the normalized click event", () => {
-    const viewer = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "x" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "one\ntwo\nthree\nfour\nfive\nsix" }] },
-      ] as any),
-      record(),
-      undefined,
-      theme,
-      vi.fn(),
-    );
-    expect(viewer.render(120).join("\n")).not.toContain("six");
-    const span = (viewer as any).timeline.getSnapshot().toolSpans[0];
-    expect(span.clickStartLine).toEqual(expect.any(Number));
-    const hintY = viewerY(span.clickStartLine);
-    expect(viewer.handleMouse(mouse("press", hintY))?.handled).toBe(true);
-    expect(viewer.render(120).join("\n")).not.toContain("six");
-    viewer.handleMouse(mouse("click", hintY, { clickCount: 1 }));
-    expect(viewer.render(120).join("\n")).toContain("six");
-  });
-
-  it("focuses USER and ASSISTANT blocks from their rendered spans", () => {
-    const viewer = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([
-        { role: "user", content: "user text" },
-        { role: "assistant", content: [{ type: "text", text: "assistant text" }] },
-      ] as any),
-      record(),
-      undefined,
-      theme,
-      vi.fn(),
-    );
-
-    viewer.render(120);
-    const timeline = (viewer as any).timeline;
-    const spans = timeline.getSnapshot().blockSpans;
-    expect(spans).toHaveLength(2);
-    viewer.handleMouse(mouse("click", viewerY(spans[1].startLine), { clickCount: 1 }));
-    expect((viewer as any).selectedMessageIdx).toBe(1);
-    expect(timeline.getFocusedToolCallId()).toBeUndefined();
-    viewer.handleMouse(mouse("click", viewerY(spans[0].startLine), { clickCount: 1 }));
-    expect((viewer as any).selectedMessageIdx).toBe(0);
-    expect(timeline.getFocusedToolCallId()).toBeUndefined();
-  });
-
-  it("focuses normal tool rows without expanding, while hint clicks expand", () => {
-    const viewer = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "x" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "one\ntwo\nthree\nfour\nfive\nsix" }] },
-      ] as any),
-      record(),
-      undefined,
-      theme,
-      vi.fn(),
-    );
-
-    expect(viewer.render(120).join("\n")).not.toContain("six");
-    const timeline = (viewer as any).timeline;
-    const initialSpan = timeline.getSnapshot().toolSpans[0];
-    const toolId = initialSpan.toolCallId;
-    const hintLine = initialSpan.clickStartLine as number;
-    const normalOutputLine = hintLine - 1;
-
-    const press = viewer.handleMouse(mouse("press", viewerY(hintLine)));
-    expect(press).toMatchObject({ handled: true, capture: true });
-    expect(timeline.getFocusedToolCallId()).toBeUndefined();
-    expect(viewer.render(120).join("\n")).not.toContain("six");
-
-    viewer.handleMouse(mouse("click", viewerY(normalOutputLine), { clickCount: 1 }));
-    expect(timeline.getFocusedToolCallId()).toBe(toolId);
-    expect((viewer as any).selectedMessageIdx).toBe(initialSpan.blockIndex);
-    expect(viewer.render(120).join("\n")).not.toContain("six");
-
-    const collapsedSpan = timeline.getSnapshot().toolSpans[0];
-    viewer.handleMouse(mouse("click", viewerY(collapsedSpan.clickStartLine as number), { clickCount: 1 }));
-    expect(timeline.getFocusedToolCallId()).toBe(toolId);
-    expect(viewer.render(120).join("\n")).toContain("six");
-  });
-
-  it("synchronizes J/K message focus and anchors [/] around the selected message", () => {
-    const viewer = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([
-        { role: "user", content: "user one" },
-        { role: "assistant", content: [{ type: "text", text: "assistant one" }] },
-        { role: "assistant", content: [{ type: "toolCall", id: "tool-1", name: "read", arguments: { path: "one" } }] },
-        { role: "toolResult", toolCallId: "tool-1", toolName: "read", content: [{ type: "text", text: "one" }] },
-        { role: "assistant", content: [{ type: "text", text: "assistant two" }] },
-        { role: "assistant", content: [{ type: "toolCall", id: "tool-2", name: "read", arguments: { path: "two" } }] },
-        { role: "toolResult", toolCallId: "tool-2", toolName: "read", content: [{ type: "text", text: "two" }] },
-      ] as any),
-      record(),
-      undefined,
-      theme,
-      vi.fn(),
-    );
-
-    viewer.render(120);
-    const timeline = (viewer as any).timeline;
-    const snapshot = timeline.getSnapshot();
-    viewer.handleInput("]");
-    expect((viewer as any).selectedMessageIdx).toBe(snapshot.toolSpans[0].blockIndex);
-    expect(timeline.getFocusedToolCallId()).toBe("tool-1");
-
-    viewer.handleInput("J");
-    expect((viewer as any).selectedMessageIdx).toBe(3);
-    expect(timeline.getFocusedToolCallId()).toBeUndefined();
-    viewer.handleInput("]");
-    expect((viewer as any).selectedMessageIdx).toBe(snapshot.toolSpans[1].blockIndex);
-    expect(timeline.getFocusedToolCallId()).toBe("tool-2");
-
-    viewer.handleInput("K");
-    expect((viewer as any).selectedMessageIdx).toBe(3);
-    expect(timeline.getFocusedToolCallId()).toBeUndefined();
-    viewer.handleInput("[");
-    expect((viewer as any).selectedMessageIdx).toBe(snapshot.toolSpans[0].blockIndex);
-    expect(timeline.getFocusedToolCallId()).toBe("tool-1");
-  });
-
-  it("uses the first or last tool for initial [/], before an explicit focus exists", () => {
-    const source = createStaticConversationSource([
-      { role: "assistant", content: [{ type: "toolCall", id: "tool-1", name: "read", arguments: { path: "one" } }] },
-      { role: "toolResult", toolCallId: "tool-1", toolName: "read", content: [{ type: "text", text: "one" }] },
-      { role: "assistant", content: [{ type: "toolCall", id: "tool-2", name: "read", arguments: { path: "two" } }] },
-      { role: "toolResult", toolCallId: "tool-2", toolName: "read", content: [{ type: "text", text: "two" }] },
-    ] as any);
-    const makeViewer = () => new ConversationViewer(tui(), source, record(), undefined, theme, vi.fn());
-
-    const left = makeViewer();
-    left.render(120);
-    left.handleInput("[");
-    expect((left as any).timeline.getFocusedToolCallId()).toBe("tool-2");
-
-    const right = makeViewer();
-    right.render(120);
-    right.handleInput("]");
-    expect((right as any).timeline.getFocusedToolCallId()).toBe("tool-1");
-  });
-
-  it("highlights the collapsed tool hint and the viewer close control independently", () => {
-    const semanticTheme = {
-      fg: (name: string, text: string) => `<${name}>${text}</${name}>`,
-      bold: (text: string) => `<bold>${text}</bold>`,
-    };
-    const done = vi.fn();
-    const viewer = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "x" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "one\ntwo\nthree\nfour\nfive\nsix" }] },
-      ] as any),
-      record(),
-      undefined,
-      semanticTheme,
-      done,
-    );
-    const initial = viewer.render(120).join("\n");
-    const span = (viewer as any).timeline.getSnapshot().toolSpans[0];
-    const hintY = viewerY(span.clickStartLine);
-    expect(initial).not.toContain("<text>click to show more</text>");
-    viewer.handleMouse(mouse("move", hintY, { button: "none" }));
-    expect(viewer.render(120).join("\n")).toContain("<text>click to show more</text>");
-    viewer.handleMouse(mouse("move", 1, { button: "none", x: 114, screenX: 114, screenY: 1 }));
-    expect(viewer.render(120).join("\n")).toContain("<text><bold>[esc]</bold></text>");
-    expect(viewer.handleMouse(mouse("press", 1, { x: 114, screenX: 114 }))?.handled).toBe(true);
-    expect(viewer.handleMouse(mouse("click", 1, { x: 114, screenX: 114, clickCount: 1 }))?.handled).toBe(true);
-    expect(done).toHaveBeenCalledTimes(1);
-  });
-
-  it("focuses nearby tools with [ and ] and opens a complete read-only preview with w", () => {
-    const ui = tui();
-    let preview: any;
-    const previewDone = vi.fn();
-    const custom = vi.fn((factory: any) => {
-      preview = factory(ui, theme, undefined, previewDone);
-      const initial = preview.render(100).join("\\n");
-      expect(initial).toContain("Input");
-      expect(initial).toContain("Output");
-      expect(initial).toContain("line 1");
-      expect(initial).not.toContain("line 40");
-      preview.handleInput("G");
-      expect(preview.render(100).join("\\n")).toContain("line 40");
-      preview.handleInput("k");
-      preview.handleInput("j");
-      preview.handleInput("g");
-      preview.handleInput("g");
-      expect(preview.render(100).join("\\n")).toContain("line 1");
-      preview.handleInput("q");
-      expect(previewDone).toHaveBeenCalledTimes(1);
-      return Promise.resolve(undefined);
-    });
-    const viewer = new ConversationViewer(
-      ui,
-      createStaticConversationSource([
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "first" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: Array.from({ length: 40 }, (_, index) => `line ${index + 1}`).join("\n") }] },
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "second" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "second output" }] },
-      ] as any),
-      record(),
-      undefined,
-      theme,
-      vi.fn(),
-      undefined,
-      undefined,
-      undefined,
-      { pi: {} as any, ctx: { ui: { custom } } as any, readOnly: true },
-    );
-    viewer.render(120);
-    const timeline = (viewer as any).timeline;
-    const ids = timeline.getSnapshot().interactiveToolIds;
-    viewer.handleInput("]");
-    expect(timeline.getFocusedToolCallId()).toBe(ids[0]);
-    viewer.render(120);
-    viewer.handleInput("w");
-    expect(custom).toHaveBeenCalledWith(expect.any(Function), expect.objectContaining({ overlay: true }));
-    preview.handleInput("G");
-    preview.handleInput("g");
-    preview.handleInput("g");
-    preview.handleInput("q");
-    viewer.handleInput("]");
-    expect(timeline.getFocusedToolCallId()).toBe(ids[1]);
-    viewer.handleInput("[");
-    expect(timeline.getFocusedToolCallId()).toBe(ids[0]);
-  });
-
-  it("keeps historical viewers read-only and closes on Escape", () => {
-    const ui = tui();
-    const steer = vi.fn();
-    const stop = vi.fn();
-    const done = vi.fn();
-    const viewer = new ConversationViewer(
-      ui,
-      createStaticConversationSource([{ role: "assistant", content: "history" }] as any),
-      record({ status: "running", session: {} }),
-      undefined,
-      theme,
-      done,
-      stop,
-      undefined,
-      steer,
-      { pi: {} as any, ctx: {} as any, readOnly: true },
-    );
-
-    viewer.handleInput("\r");
-    viewer.handleInput("x");
-    viewer.handleInput("O");
-    expect(steer).not.toHaveBeenCalled();
-    expect(stop).not.toHaveBeenCalled();
-    viewer.handleInput("\x1b");
-    expect(done).toHaveBeenCalledTimes(1);
-  });
-});

package/test/ui/fleet-list.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-  calculateFleetAgentWindow,
-  FLEET_MAX_RENDER_ROWS,
-  FleetList,
-} from "../../src/ui/fleet-list.js";
-import { canOpenActiveAgent } from "../../src/agent-history-list.js";
-
-const theme = {
-  fg: (_color: string, text: string) => text,
-  bold: (text: string) => text,
-};
-
-function makeAgents(count: number): any[] {
-  return Array.from({ length: count }, (_, i) => ({
-    id: `agent-${i}`,
-    type: "Explore",
-    description: `agent ${i}`,
-    status: "running",
-    session: { messages: [], subscribe: () => () => {} },
-    toolUses: 0,
-    startedAt: i + 1,
-    lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-    compactionCount: 0,
-  }));
-}
-
-function createFleetHarness(records: any[]) {
-  const manager: any = {
-    records,
-    listAgents() { return this.records; },
-    abort: vi.fn(() => false),
-    steer: vi.fn(() => false),
-  };
-  const tui = { terminal: { rows: 24 }, requestRender: vi.fn() } as any;
-  let terminalInput: ((data: string) => { consume?: boolean } | undefined) | undefined;
-  let factory: any;
-  const ui: any = {
-    setWidget: vi.fn((_key: string, content: any) => { factory = content; }),
-    onTerminalInput: (handler: typeof terminalInput) => {
-      terminalInput = handler;
-      return () => { terminalInput = undefined; };
-    },
-    getEditorText: () => "",
-    notify: vi.fn(),
-    custom: vi.fn(async () => undefined),
-  };
-  const fleet = new FleetList(manager, new Map());
-  fleet.setUICtx(ui);
-  fleet.update();
-  const render = (width = 120) => factory ? factory(tui, theme).render(width) : [];
-  const input = (data: string) => terminalInput?.(data);
-  render(); // The real TUI invokes the widget factory before keyboard input arrives.
-  return { manager, fleet, tui, ui, render, input };
-}
-
-describe("canOpenActiveAgent", () => {
-  it("does not treat terminal records as active FleetView rows", () => {
-    expect(canOpenActiveAgent({ status: "completed", session: {} } as any)).toBe(false);
-    expect(canOpenActiveAgent({ status: "error", session: {} } as any)).toBe(false);
-    expect(canOpenActiveAgent({ status: "running", session: {} } as any)).toBe(true);
-    expect(canOpenActiveAgent({ status: "queued", session: undefined } as any)).toBe(false);
-  });
-});
-
-describe("FleetList bounded window", () => {
-  it("keeps every FleetView state within six total rows", () => {
-    for (const agentCount of [0, 1, 2, 4, 5, 12]) {
-      for (let selected = 0; selected <= agentCount; selected++) {
-        const window = calculateFleetAgentWindow(agentCount, selected);
-        const rows = 2 + (window.hiddenAbove > 0 ? 1 : 0)
-          + (window.end - window.start)
-          + (window.hiddenBelow > 0 ? 1 : 0);
-        expect(rows).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
-        if (agentCount > 0 && selected > 0) {
-          expect(selected - 1).toBeGreaterThanOrEqual(window.start);
-          expect(selected - 1).toBeLessThan(window.end);
-        }
-      }
-    }
-  });
-
-  it("reserves indicator rows while keeping the selected middle agent visible", () => {
-    const window = calculateFleetAgentWindow(12, 6);
-    expect(window.hiddenAbove).toBeGreaterThan(0);
-    expect(window.hiddenBelow).toBeGreaterThan(0);
-    expect(5).toBeGreaterThanOrEqual(window.start);
-    expect(5).toBeLessThan(window.end);
-  });
-
-  it("slides the visible window while navigating the full roster", () => {
-    const { render, input } = createFleetHarness(makeAgents(12));
-    input("\u001b[B");
-    for (let i = 0; i < 6; i++) input("\u001b[B");
-    const middle = render();
-    expect(middle.length).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
-    expect(middle.some(line => /↑ \d+ more/.test(line))).toBe(true);
-    expect(middle.some(line => /↓ \d+ more/.test(line))).toBe(true);
-    expect(middle.some(line => line.includes("●"))).toBe(true);
-
-    input("\u001b[A");
-    const afterUp = render();
-    expect(afterUp.length).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
-    expect(afterUp.some(line => line.includes("●"))).toBe(true);
-  });
-
-  it("keeps the first and last windows bounded", () => {
-    const { render, input } = createFleetHarness(makeAgents(12));
-    expect(render().length).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
-    input("\u001b[B");
-    for (let i = 0; i < 12; i++) input("\u001b[B");
-    const last = render();
-    expect(last.length).toBeLessThanOrEqual(FLEET_MAX_RENDER_ROWS);
-    expect(last.some(line => /↓ \d+ more/.test(line))).toBe(false);
-  });
-
-  it("skips unchanged timer updates but redraws once when the active roster changes", () => {
-    const { manager, fleet, tui } = createFleetHarness(makeAgents(5));
-    tui.requestRender.mockClear();
-    fleet.update();
-    expect(tui.requestRender).not.toHaveBeenCalled();
-
-    manager.records.pop();
-    fleet.update();
-    expect(tui.requestRender).toHaveBeenCalledWith(true);
-    fleet.dispose();
-  });
-
-  it("clears the widget when the active roster becomes empty", () => {
-    const { manager, fleet, ui } = createFleetHarness(makeAgents(1));
-    manager.records.splice(0);
-    fleet.update();
-    expect(ui.setWidget).toHaveBeenLastCalledWith("fleet", undefined);
-  });
-});

package/test/write-execution.test.ts

@@ -1,83 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  executeWriteWithMetadata,
-  MAX_DURABLE_DIFF_BYTES,
-  WriteExecutionMetadataStore,
-} from "../src/write-execution.js";
-
-const tempDirs: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-
-async function tempDir(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "pi-subagents-write-test-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-describe("executeWriteWithMetadata", () => {
-  it("writes a new file and returns a durable display diff and patch", async () => {
-    const cwd = await tempDir();
-    const store = new WriteExecutionMetadataStore();
-    const result = await executeWriteWithMetadata(store, "call-new", {
-      path: "nested/file.txt",
-      content: "new\n",
-    }, undefined, cwd);
-
-    expect(await readFile(join(cwd, "nested/file.txt"), "utf8")).toBe("new\n");
-    expect(result.content[0]?.text).toContain("Successfully wrote to nested/file.txt");
-    expect(result.details?.diff).toContain("+1 new");
-    expect(result.details?.patch).toContain("+new");
-    expect(store.get("call-new")?.diff).toBe(result.details?.diff);
-  });
-
-  it("returns durable details that remain independent of later file changes", async () => {
-    const cwd = await tempDir();
-    await writeFile(join(cwd, "file.txt"), "old\n", "utf8");
-    const store = new WriteExecutionMetadataStore();
-    const result = await executeWriteWithMetadata(store, "call-existing", {
-      path: "file.txt",
-      content: "new\n",
-    }, undefined, cwd);
-    const persisted = { ...result.details };
-
-    await writeFile(join(cwd, "file.txt"), "later\n", "utf8");
-
-    expect(persisted.diff).toContain("-1 old");
-    expect(persisted.diff).toContain("+1 new");
-    expect(persisted.patch).toContain("-old");
-    expect(persisted.patch).toContain("+new");
-    expect(persisted).not.toHaveProperty("previousContent");
-  });
-
-  it("writes successfully but marks an oversized durable diff unavailable", async () => {
-    const cwd = await tempDir();
-    const store = new WriteExecutionMetadataStore();
-    const content = "x".repeat(MAX_DURABLE_DIFF_BYTES + 1);
-    const result = await executeWriteWithMetadata(store, "call-large", {
-      path: "large.txt",
-      content,
-    }, undefined, cwd);
-
-    expect((await readFile(join(cwd, "large.txt"), "utf8")).length).toBe(content.length);
-    expect(result.details?.diffUnavailableReason).toContain("durable diff exceeds");
-    expect(result.details).not.toHaveProperty("diff");
-    expect(store.get("call-large")?.previousContent).toBe("");
-  });
-
-  it("does not fabricate metadata when the write fails", async () => {
-    const cwd = await tempDir();
-    const store = new WriteExecutionMetadataStore();
-
-    await expect(executeWriteWithMetadata(store, "call-fail", {
-      path: "/dev/null/pi-subagents-impossible/file.txt",
-      content: "nope",
-    }, undefined, cwd)).rejects.toBeTruthy();
-    expect(store.get("call-fail")).toBeUndefined();
-  });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "rootDir": "src",
-    "outDir": "dist",
-    "skipLibCheck": true,
-    "noEmitOnError": true
-  },
-  "include": ["src/**/*.ts"]
-}