@aaroncql/pim-agent 0.0.1 → 0.1.0

package/src/extensions/subagent/render.test.ts

@@ -1,292 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  AgentToolResult,
-  Theme,
-  ThemeColor,
-} from "@earendil-works/pi-coding-agent";
-import type { SubagentDetails } from "./subagent";
-import {
-  formatCallTitle,
-  formatTopLine,
-  renderCall,
-  renderResult,
-} from "./render";
-
-const stubTheme = {
-  bold: (text: string) => text,
-  italic: (text: string) => text,
-  strikethrough: (text: string) => text,
-  underline: (text: string) => text,
-  fg: (_color: string, text: string) => text,
-} as unknown as Theme;
-
-type ColorCall = {
-  readonly color: ThemeColor;
-  readonly text: string;
-};
-
-function tracingTheme(): {
-  readonly theme: Theme;
-  readonly calls: ColorCall[];
-} {
-  const calls: ColorCall[] = [];
-  return {
-    calls,
-    theme: {
-      bold: (text: string) => text,
-      italic: (text: string) => text,
-      strikethrough: (text: string) => text,
-      underline: (text: string) => text,
-      fg: (color: ThemeColor, text: string) => {
-        calls.push({ color, text });
-        return text;
-      },
-    } as unknown as Theme,
-  };
-}
-
-const baseDetails: SubagentDetails = {
-  returnedOutput: "body",
-  fullOutput: "body",
-  outputTruncated: false,
-  omittedBytes: 0,
-  usage: {
-    input: 10,
-    output: 5,
-    cacheRead: 2,
-    cacheWrite: 0,
-    cost: 0.23,
-    turns: 3,
-    contextTokens: 4000,
-  },
-  toolCalls: [{ name: "read", isError: false }],
-  activeToolNames: [],
-  lastToolName: "read",
-  stopReason: "stop",
-  errorMessage: undefined,
-  model: "deepseek-v4-flash",
-  contextWindow: 1_000_000,
-  topLine: "$0.23 ⬝ 0.4%/1.0M ⬝ deepseek-v4-flash ⬝ 3 turns ⬝ 1 tool",
-};
-
-function result(text: string): AgentToolResult<SubagentDetails> {
-  return { content: [{ type: "text", text }], details: baseDetails };
-}
-
-describe("subagent render formatting", () => {
-  test("call title uses the first line without truncating", () => {
-    const long = `${"x".repeat(140)}\nsecond`;
-
-    expect(formatCallTitle(long)).toBe("x".repeat(140));
-  });
-
-  test("top line includes cost, context, model, and activity", () => {
-    expect(formatTopLine(baseDetails)).toBe(
-      "$0.23 ⬝ 0.4%/1.0M ⬝ deepseek-v4-flash ⬝ 3 turns ⬝ 1 tool"
-    );
-  });
-
-  test("call title renders prompt markdown", () => {
-    const component = renderCall(
-      { prompt: "Review **bold** and `code`" },
-      stubTheme,
-      {
-        lastComponent: undefined,
-        isPartial: false,
-        isError: false,
-      }
-    );
-
-    expect(component.render(80)[0]?.trimEnd()).toBe(
-      " ▪ Subagent: Review bold and code"
-    );
-  });
-
-  test("call title uses the default color for prompt text", () => {
-    const rendered = tracingTheme();
-    renderCall({ prompt: "plain prompt" }, rendered.theme, {
-      lastComponent: undefined,
-      isPartial: false,
-      isError: false,
-    }).render(80);
-
-    expect(rendered.calls).not.toContainEqual({
-      color: "toolTitle",
-      text: "plain prompt",
-    });
-  });
-
-  test("call title colors the Subagent label by running status", () => {
-    const pending = tracingTheme();
-    renderCall({ prompt: "investigate" }, pending.theme, {
-      lastComponent: undefined,
-      isPartial: true,
-      isError: false,
-    }).render(80);
-
-    expect(pending.calls).toContainEqual({
-      color: "warning",
-      text: "Subagent",
-    });
-
-    const done = tracingTheme();
-    renderCall({ prompt: "investigate" }, done.theme, {
-      lastComponent: undefined,
-      isPartial: false,
-      isError: false,
-    }).render(80);
-
-    expect(done.calls).toContainEqual({ color: "accent", text: "Subagent" });
-  });
-
-  test("top line uses muted dots with accent or warning content", () => {
-    const done = tracingTheme();
-    renderResult(
-      result("body"),
-      { expanded: false, isPartial: false },
-      done.theme,
-      { lastComponent: undefined, isPartial: false, isError: false }
-    ).render(80);
-
-    expect(done.calls).toContainEqual({ color: "accent", text: "$0.23 " });
-    expect(done.calls).toContainEqual({ color: "muted", text: "⬝" });
-
-    const running = tracingTheme();
-    renderResult(
-      {
-        content: [{ type: "text", text: "ignored body" }],
-        details: { ...baseDetails, stopReason: undefined },
-      },
-      { expanded: false, isPartial: true },
-      running.theme,
-      { lastComponent: undefined, isPartial: true, isError: false }
-    ).render(80);
-
-    expect(running.calls).toContainEqual({ color: "warning", text: "$0.23 " });
-    expect(running.calls).toContainEqual({ color: "muted", text: "⬝" });
-  });
-
-  test("partial render displays only the running top line", () => {
-    const runningDetails: SubagentDetails = {
-      ...baseDetails,
-      toolCalls: [],
-      activeToolNames: ["grep"],
-      stopReason: undefined,
-      topLine: "$0.23 ⬝ 0.4%/1.0M ⬝ deepseek-v4-flash ⬝ 3 turns ⬝ grep",
-    };
-    const component = renderResult(
-      {
-        content: [{ type: "text", text: "ignored body" }],
-        details: runningDetails,
-      },
-      { expanded: false, isPartial: true },
-      stubTheme,
-      { lastComponent: undefined, isPartial: true, isError: false }
-    );
-
-    expect(component.render(80)).toEqual([` │ ${runningDetails.topLine}`]);
-  });
-
-  test("collapsed done render hides the final message", () => {
-    const body = Array.from({ length: 12 }, (_, i) => `line ${i + 1}`).join(
-      "\n"
-    );
-    const component = renderResult(
-      result(body),
-      { expanded: false, isPartial: false },
-      stubTheme,
-      { lastComponent: undefined, isPartial: false, isError: false }
-    );
-
-    expect(component.render(80)).toEqual([` │ ${baseDetails.topLine}`]);
-  });
-
-  test("expanded done render keeps the top line above the final message", () => {
-    const component = renderResult(
-      result("line 1\nline 2"),
-      { expanded: true, isPartial: false },
-      stubTheme,
-      { lastComponent: undefined, isPartial: false, isError: false }
-    );
-
-    expect(component.render(80)).toEqual([
-      ` │ ${baseDetails.topLine}`,
-      " │ line 1",
-      " │ line 2",
-    ]);
-  });
-
-  test("expanded done render renders final message markdown", () => {
-    const component = renderResult(
-      result("Final **answer** and `code`"),
-      { expanded: true, isPartial: false },
-      stubTheme,
-      { lastComponent: undefined, isPartial: false, isError: false }
-    );
-
-    expect(component.render(80)).toEqual([
-      ` │ ${baseDetails.topLine}`,
-      " │ Final answer and code",
-    ]);
-  });
-
-  test("expanded done render uses configured markdown theme tokens", () => {
-    const rendered = tracingTheme();
-    renderResult(
-      result(
-        [
-          "# Heading",
-          "",
-          "[docs](https://example.test)",
-          "",
-          "`inline`",
-          "",
-          "> quoted",
-          "",
-          "- item",
-          "",
-          "```",
-          "plain code",
-          "```",
-          "",
-          "---",
-        ].join("\n")
-      ),
-      { expanded: true, isPartial: false },
-      rendered.theme,
-      { lastComponent: undefined, isPartial: false, isError: false }
-    ).render(120);
-
-    const colors = new Set(rendered.calls.map((call) => call.color));
-    const expectedColors = [
-      "mdHeading",
-      "mdLink",
-      "mdCode",
-      "mdQuote",
-      "mdQuoteBorder",
-      "mdListBullet",
-      "mdCodeBlock",
-      "mdCodeBlockBorder",
-      "mdHr",
-    ] satisfies readonly ThemeColor[];
-
-    for (const color of expectedColors) {
-      expect(colors.has(color)).toBe(true);
-    }
-  });
-
-  test("expanded done render uses the default color for final message text", () => {
-    const rendered = tracingTheme();
-    renderResult(
-      result("plain final"),
-      { expanded: true, isPartial: false },
-      rendered.theme,
-      { lastComponent: undefined, isPartial: false, isError: false }
-    ).render(80);
-
-    expect(rendered.calls).not.toContainEqual({
-      color: "toolOutput",
-      text: "plain final",
-    });
-  });
-});

package/src/extensions/subagent/subagent.test.ts

@@ -1,315 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { AssistantMessage, Usage } from "@earendil-works/pi-ai";
-import {
-  applyOutputCap,
-  childToolNames,
-  runSubagent,
-  SubagentEventCapture,
-  type SubagentSession,
-} from "./subagent";
-
-type UsageOverrides = Omit<Partial<Usage>, "cost"> & {
-  readonly cost?: Partial<Usage["cost"]>;
-};
-
-const usage = (overrides: UsageOverrides = {}): Usage => {
-  const { cost, ...rest } = overrides;
-  return {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    totalTokens: 0,
-    cost: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      total: 0,
-      ...cost,
-    },
-    ...rest,
-  };
-};
-
-function assistant(
-  textParts: readonly string[],
-  overrides: Partial<AssistantMessage> = {}
-): AssistantMessage {
-  return {
-    role: "assistant",
-    content: textParts.map((text) => ({ type: "text", text })),
-    api: "anthropic-messages",
-    provider: "anthropic",
-    model: "claude-test",
-    usage: usage(),
-    stopReason: "stop",
-    timestamp: 1,
-    ...overrides,
-  };
-}
-
-const ctx = { cwd: "/work" } as ExtensionContext;
-
-class FakeSession implements SubagentSession {
-  public promptCalls = 0;
-  public abortCalls = 0;
-  public disposeCalls = 0;
-  private listener: ((event: never) => void) | undefined;
-
-  public constructor(
-    private readonly onPrompt: (
-      session: FakeSession,
-      prompt: string
-    ) => Promise<void>
-  ) {}
-
-  public subscribe(listener: (event: never) => void): () => void {
-    this.listener = listener;
-    return () => {
-      this.listener = undefined;
-    };
-  }
-
-  public emit(event: unknown): void {
-    this.listener?.(event as never);
-  }
-
-  public async prompt(prompt: string): Promise<void> {
-    this.promptCalls += 1;
-    await this.onPrompt(this, prompt);
-  }
-
-  public async abort(): Promise<void> {
-    this.abortCalls += 1;
-  }
-
-  public dispose(): void {
-    this.disposeCalls += 1;
-  }
-}
-
-describe("childToolNames", () => {
-  test("removes the subagent tool from a child's inherited allowlist", () => {
-    expect(childToolNames(["read", "subagent", "bash"])).toEqual([
-      "read",
-      "bash",
-    ]);
-  });
-});
-
-describe("SubagentEventCapture", () => {
-  test("concatenates multi-part text, resets for each assistant message, and records usage/tools", () => {
-    const updates: string[] = [];
-    const capture = new SubagentEventCapture((partial) => {
-      updates.push(
-        partial.content[0]?.type === "text" ? partial.content[0].text : ""
-      );
-    });
-
-    capture.handle({ type: "message_start", message: assistant([]) } as never);
-    capture.handle({
-      type: "message_end",
-      message: assistant(["first ", "turn"], {
-        usage: usage({ input: 10, output: 4, cost: { total: 0.01 } }),
-      }),
-    } as never);
-    capture.handle({
-      type: "tool_execution_end",
-      toolCallId: "1",
-      toolName: "read",
-      result: {},
-      isError: false,
-    } as never);
-    capture.handle({ type: "message_start", message: assistant([]) } as never);
-    capture.handle({
-      type: "message_end",
-      message: assistant(["final", " answer"], {
-        usage: usage({
-          input: 2,
-          output: 8,
-          cacheRead: 3,
-          cost: { total: 0.02 },
-        }),
-      }),
-    } as never);
-
-    const snapshot = capture.snapshot();
-    expect(snapshot.finalOutput).toBe("final answer");
-    expect(snapshot.usage).toEqual({
-      input: 12,
-      output: 12,
-      cacheRead: 3,
-      cacheWrite: 0,
-      cost: 0.03,
-      turns: 2,
-      contextTokens: undefined,
-    });
-    expect(snapshot.toolCalls).toEqual([{ name: "read", isError: false }]);
-    expect(snapshot.lastToolName).toBe("read");
-    expect(updates.at(-1)).toBe("$0.03 ⬝ ?/? ⬝ claude-test ⬝ 2 turns ⬝ 1 tool");
-  });
-
-  test("a later message with no text discards the prior message's text", () => {
-    const capture = new SubagentEventCapture();
-
-    capture.handle({ type: "message_start", message: assistant([]) } as never);
-    capture.handle({
-      type: "message_end",
-      message: assistant(["intro"], { stopReason: "toolUse" }),
-    } as never);
-    capture.handle({ type: "message_start", message: assistant([]) } as never);
-    capture.handle({
-      type: "message_end",
-      message: assistant([], { stopReason: "stop" }),
-    } as never);
-
-    expect(capture.snapshot().finalOutput).toBe("");
-  });
-
-  test("message_update content is materialized lazily on snapshot read", () => {
-    const capture = new SubagentEventCapture();
-
-    capture.handle({ type: "message_start", message: assistant([]) } as never);
-    capture.handle({
-      type: "message_update",
-      message: assistant(["partial"]),
-    } as never);
-
-    expect(capture.snapshot().finalOutput).toBe("partial");
-  });
-});
-
-describe("applyOutputCap", () => {
-  test("truncates on a UTF-8 boundary and reports omitted bytes", () => {
-    const capped = applyOutputCap("😀😀😀", 5);
-
-    expect(capped.text).toContain(
-      "😀\n[subagent: output truncated, 8 bytes omitted"
-    );
-    expect(capped.text).not.toContain("�");
-    expect(capped.truncated).toBe(true);
-    expect(capped.omittedBytes).toBe(8);
-  });
-});
-
-describe("runSubagent", () => {
-  test("returns bare text on normal completion", async () => {
-    const fake = new FakeSession(async (session) => {
-      session.emit({ type: "message_start", message: assistant([]) });
-      session.emit({
-        type: "message_end",
-        message: assistant(["hello"]),
-      });
-    });
-
-    const result = await runSubagent(
-      "say hi",
-      ctx,
-      undefined,
-      undefined,
-      async () => fake
-    );
-
-    expect(result.content).toEqual([{ type: "text", text: "hello" }]);
-    expect(result.details.fullOutput).toBe("hello");
-    expect(fake.promptCalls).toBe(1);
-    expect(fake.abortCalls).toBe(1);
-    expect(fake.disposeCalls).toBe(1);
-  });
-
-  test("returns a hint, not an error, for normal empty output", async () => {
-    const fake = new FakeSession(async (session) => {
-      session.emit({ type: "message_start", message: assistant([]) });
-      session.emit({ type: "message_end", message: assistant([]) });
-    });
-
-    const result = await runSubagent(
-      "empty",
-      ctx,
-      undefined,
-      undefined,
-      async () => fake
-    );
-
-    expect(
-      result.content[0]?.type === "text" ? result.content[0].text : ""
-    ).toBe("[subagent tool: completed with no text output.]");
-  });
-
-  test("throws on model error with partial output", async () => {
-    const fake = new FakeSession(async (session) => {
-      session.emit({ type: "message_start", message: assistant([]) });
-      session.emit({
-        type: "message_end",
-        message: assistant(["partial"], {
-          stopReason: "error",
-          errorMessage: "provider exploded",
-        }),
-      });
-    });
-
-    await expect(
-      runSubagent("fail", ctx, undefined, undefined, async () => fake)
-    ).rejects.toThrow(
-      "Subagent failed: error. Error: provider exploded.\nPartial output before failure:\npartial"
-    );
-  });
-
-  test("rejects pre-aborted signals before prompt", async () => {
-    const controller = new AbortController();
-    controller.abort();
-    const fake = new FakeSession(async () => {});
-
-    await expect(
-      runSubagent("abort", ctx, controller.signal, undefined, async () => fake)
-    ).rejects.toThrow("Subagent failed: subagent aborted before start");
-
-    expect(fake.promptCalls).toBe(0);
-    expect(fake.abortCalls).toBe(1);
-    expect(fake.disposeCalls).toBe(1);
-  });
-
-  test("mid-run abort aborts once, tears down, and rejects", async () => {
-    let finishPrompt: (() => void) | undefined;
-    const fake = new (class extends FakeSession {
-      public override async abort(): Promise<void> {
-        await super.abort();
-        finishPrompt?.();
-      }
-    })(
-      () =>
-        new Promise<void>((resolve) => {
-          finishPrompt = resolve;
-        })
-    );
-    const controller = new AbortController();
-    const promise = runSubagent(
-      "long",
-      ctx,
-      controller.signal,
-      undefined,
-      async () => fake
-    );
-
-    await Promise.resolve();
-    controller.abort();
-
-    await expect(promise).rejects.toThrow("Subagent failed: aborted");
-    expect(fake.promptCalls).toBe(1);
-    expect(fake.abortCalls).toBe(1);
-    expect(fake.disposeCalls).toBe(1);
-  });
-
-  test("nested subagent calls are rejected by the async-local recursion ban", async () => {
-    const outer = new FakeSession(async () => {
-      const inner = new FakeSession(async () => {});
-      await runSubagent("inner", ctx, undefined, undefined, async () => inner);
-    });
-
-    await expect(
-      runSubagent("outer", ctx, undefined, undefined, async () => outer)
-    ).rejects.toThrow("subagents cannot call subagent tool");
-  });
-});

package/src/extensions/system-prompt/prompt.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildSystemPrompt, describeOs } from "./prompt";
-
-describe("buildSystemPrompt", () => {
-  test("emits a best-effort os field instead of process.platform", () => {
-    const prompt = buildSystemPrompt({
-      cwd: "/repo",
-      contextFiles: [],
-      skillsBlock: "",
-      toolGuidelines: [],
-      os: "Ubuntu 24.04.2 LTS",
-    });
-
-    expect(prompt).toContain("- os: Ubuntu 24.04.2 LTS");
-    expect(prompt).not.toContain("- platform:");
-  });
-});
-
-describe("describeOs", () => {
-  test("uses PRETTY_NAME from /etc/os-release on Linux", () => {
-    const os = describeOs({
-      platform: "linux",
-      runCommand: (cmd) =>
-        cmd.join(" ") === "cat /etc/os-release"
-          ? 'NAME="Ubuntu"\nVERSION="24.04.2 LTS"\nPRETTY_NAME="Ubuntu 24.04.2 LTS"\n'
-          : undefined,
-    });
-
-    expect(os).toBe("Ubuntu 24.04.2 LTS");
-  });
-
-  test("formats macOS from sw_vers", () => {
-    const os = describeOs({
-      platform: "darwin",
-      runCommand: (cmd) =>
-        cmd.join(" ") === "sw_vers"
-          ? "ProductName:\t\tmacOS\nProductVersion:\t15.5\nBuildVersion:\t\t24F74\n"
-          : undefined,
-    });
-
-    expect(os).toBe("macOS 15.5");
-  });
-
-  test("falls back to process platform when no probe succeeds", () => {
-    const os = describeOs({
-      platform: "linux",
-      runCommand: () => undefined,
-    });
-
-    expect(os).toBe("linux");
-  });
-
-  test("falls back to NAME and VERSION when PRETTY_NAME is absent", () => {
-    const os = describeOs({
-      platform: "linux",
-      runCommand: (cmd) =>
-        cmd.join(" ") === "cat /etc/os-release"
-          ? 'NAME=Fedora\nVERSION="40 (Workstation Edition)"'
-          : undefined,
-    });
-
-    expect(os).toBe("Fedora 40 (Workstation Edition)");
-  });
-});