@pi-archimedes/subagent 2.0.1 → 2.1.0

package/src/compact.test.ts

@@ -0,0 +1,437 @@
+import { describe, it, expect, vi } from "vitest";
+import * as fc from "fast-check";
+import { buildActivityLine, renderCompactSingle, renderCompactParallel } from "./compact.js";
+import type { SubagentResult, SubagentProgress, SubagentDetails, SubagentToolCall } from "./types.js";
+
+// ── Mocks ───────────────────────────────────────────────────────────────────
+
+vi.mock("@earendil-works/pi-tui", () => {
+  class MockTextInner {
+    private _content = "";
+
+    setText(content: string): void {
+      this._content = content;
+    }
+
+    getContent(): string {
+      return this._content;
+    }
+  }
+  return {
+    Text: MockTextInner,
+  };
+});
+
+// Re-import MockText for use in tests (same class as the mock)
+import { Text as MockText } from "@earendil-works/pi-tui";
+
+// Type-safe helper: ActivityData with all optional fields for test convenience
+// ActivityData is defined in compact.ts — reconstruct the shape here
+type ActivityData = {
+  currentTool: string | undefined;
+  currentToolArgs: string | undefined;
+  currentToolStartedAt: number | undefined;
+  finalOutput: string | undefined;
+  status: "running" | "completed" | "failed" | undefined;
+  error: string | undefined;
+  toolCalls?: (SubagentToolCall | string)[] | undefined;
+};
+
+function activityData(p: Partial<ActivityData>): ActivityData {
+  return {
+    currentTool: undefined,
+    currentToolArgs: undefined,
+    currentToolStartedAt: undefined,
+    finalOutput: undefined,
+    status: undefined,
+    error: undefined,
+    toolCalls: undefined,
+    ...p,
+  };
+}
+
+// Mock theme that tracks calls for verification
+function makeMockTheme() {
+  const calls: Array<{ fn: string; args: unknown[] }> = [];
+
+  const theme = {
+    fg: (token: string, text: string) => {
+      calls.push({ fn: "fg", args: [token, text] });
+      return `[${token}]${text}[/${token}]`;
+    },
+    bold: (text: string) => {
+      calls.push({ fn: "bold", args: [text] });
+      return `**${text}**`;
+    },
+  };
+
+  return { theme, calls };
+}
+
+// ── buildActivityLine ──────────────────────────────────────────────────────
+
+describe("buildActivityLine", () => {
+  it("shows error prefix with truncated error when error is present", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({ error: "Something went wrong", status: "running" }),
+      theme,
+    );
+    expect(result).toContain("✗ Something went wrong");
+  });
+
+  it("shows '✓ Done' when status is completed", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({ status: "completed" }),
+      theme,
+    );
+    expect(result).toContain("✓ Done");
+  });
+
+  it("shows '✗ Failed' when status is failed", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({ status: "failed" }),
+      theme,
+    );
+    expect(result).toContain("✗ Failed");
+  });
+
+  it("shows tool name + args when running with current tool", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({
+        status: "running",
+        currentTool: "read",
+        currentToolArgs: '{"path": "foo.ts"}',
+      }),
+      theme,
+    );
+    expect(result).toContain("read");
+    expect(result).toContain("foo.ts");
+  });
+
+  it("shows last tool call when running with no current tool but toolCalls present", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({
+        status: "running",
+        toolCalls: [
+          { name: "bash", argsPreview: "ls -la", error: false },
+        ],
+      }),
+      theme,
+    );
+    expect(result).toContain("bash");
+  });
+
+  it("shows '↳ Starting...' when running with no info", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({ status: "running" }),
+      theme,
+    );
+    expect(result).toContain("↳ Starting...");
+  });
+
+  it("shows first line of final output when available", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({
+        status: "running",
+        finalOutput: "first line of output\nsecond line\nthird line",
+      }),
+      theme,
+    );
+    expect(result).toContain("first line of output");
+    expect(result).not.toContain("second line");
+  });
+
+  it("returns empty string when status is undefined and no data", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(activityData({}), theme);
+    expect(result).toBe("");
+  });
+
+  it("error takes priority over completed status", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({ error: "oops", status: "completed" }),
+      theme,
+    );
+    expect(result).toContain("✗ oops");
+    expect(result).not.toContain("✓ Done");
+  });
+
+  it("completed status takes priority over currentTool", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({ status: "completed", currentTool: "read" }),
+      theme,
+    );
+    expect(result).toContain("✓ Done");
+    expect(result).not.toContain("read");
+  });
+
+  it("shows string toolCall in toolCalls array", () => {
+    const { theme } = makeMockTheme();
+    const result = buildActivityLine(
+      activityData({
+        status: "running",
+        toolCalls: ["some-string-call"],
+      }),
+      theme,
+    );
+    expect(result).toContain("some-string-call");
+  });
+
+  it("colors last tool call name with error color when error flag set", () => {
+    const { theme, calls } = makeMockTheme();
+    buildActivityLine(
+      activityData({
+        status: "running",
+        toolCalls: [{ name: "bash", argsPreview: "rm -rf /", error: true }],
+      }),
+      theme,
+    );
+    // The tool name "bash" should be colored with "error" token
+    const fgCalls = calls.filter(c => c.fn === "fg");
+    const errorCall = fgCalls.find(c => c.args[0] === "error" && c.args[1] === "bash");
+    expect(errorCall).toBeDefined();
+  });
+
+  it("colors last tool call name with success color when no error", () => {
+    const { theme, calls } = makeMockTheme();
+    buildActivityLine(
+      activityData({
+        status: "running",
+        toolCalls: [{ name: "read", argsPreview: "file.ts", error: false }],
+      }),
+      theme,
+    );
+    const fgCalls = calls.filter(c => c.fn === "fg");
+    const successCall = fgCalls.find(c => c.args[0] === "success" && c.args[1] === "read");
+    expect(successCall).toBeDefined();
+  });
+});
+
+// ── renderCompactSingle ────────────────────────────────────────────────────
+
+describe("renderCompactSingle", () => {
+  function makeResult(overrides: Partial<SubagentResult> = {}): SubagentResult {
+    return {
+      agent: "test-agent",
+      task: "do something",
+      exitCode: 0,
+      usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: 0.01, turns: 3 },
+      model: "gpt-4",
+      finalOutput: undefined,
+      error: undefined,
+      progress: undefined,
+      progressSummary: { toolCount: 5, tokens: 150, durationMs: 3000 },
+      ...overrides,
+    };
+  }
+
+  it("calls setText with expected output structure for completed agent", () => {
+    const { theme } = makeMockTheme();
+    const text = new MockText();
+    const result = makeResult({ exitCode: 0 });
+    const context = { state: {}, invalidate: vi.fn() };
+
+    renderCompactSingle(text, result, undefined, theme, context);
+
+    const output = (text as unknown as { getContent(): string }).getContent();
+    expect(output).toContain("test-agent");
+    expect(output).toContain("do something");
+    expect(output).toContain("✓ Done");
+  });
+
+  it("calls setText with expected output structure for running agent", () => {
+    const { theme } = makeMockTheme();
+    const text = new MockText();
+    const result = makeResult({ exitCode: 1 });
+    const progress: SubagentProgress = {
+      agent: "test-agent",
+      status: "running",
+      task: "do something",
+      currentTool: "read",
+      currentToolArgs: undefined,
+      currentToolStartedAt: undefined,
+      toolCount: 2,
+      inputTokens: 50,
+      outputTokens: 30,
+      tokens: 80,
+      cost: 0.005,
+      durationMs: 1000,
+      error: undefined,
+      model: "gpt-4",
+      output: undefined,
+      recentOutput: undefined,
+      toolCalls: undefined,
+    };
+    const context = { state: {}, invalidate: vi.fn() };
+
+    renderCompactSingle(text, result, progress, theme, context);
+
+    const output = (text as unknown as { getContent(): string }).getContent();
+    expect(output).toContain("test-agent");
+    expect(output).toContain("read");
+  });
+
+  it("returns the text instance", () => {
+    const { theme } = makeMockTheme();
+    const text = new MockText();
+    const result = makeResult();
+    const context = { state: {}, invalidate: vi.fn() };
+
+    const returned = renderCompactSingle(text, result, undefined, theme, context);
+    expect(returned).toBe(text);
+  });
+});
+
+// ── renderCompactParallel ──────────────────────────────────────────────────
+
+describe("renderCompactParallel", () => {
+  function makeDetails(overrides: Partial<SubagentDetails> = {}): SubagentDetails {
+    return {
+      mode: "parallel",
+      results: [
+        {
+          agent: "agent-a",
+          task: "task a",
+          exitCode: 0,
+          usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+          model: undefined,
+          finalOutput: undefined,
+          error: undefined,
+          progress: undefined,
+          progressSummary: { toolCount: 0, tokens: 0, durationMs: 0 },
+        },
+        {
+          agent: "agent-b",
+          task: "task b",
+          exitCode: 1,
+          usage: { input: 200, output: 100, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+          model: undefined,
+          finalOutput: undefined,
+          error: "failed",
+          progress: undefined,
+          progressSummary: { toolCount: 0, tokens: 0, durationMs: 0 },
+        },
+      ],
+      progress: undefined,
+      ...overrides,
+    };
+  }
+
+  it("calls setText with one line per result", () => {
+    const { theme } = makeMockTheme();
+    const text = new MockText();
+    const details = makeDetails();
+    const context = { state: {}, invalidate: vi.fn() };
+
+    renderCompactParallel(text, details, theme, context);
+
+    const output = (text as unknown as { getContent(): string }).getContent();
+    expect(output).toContain("agent-a");
+    expect(output).toContain("agent-b");
+    // Two results joined by newline
+    const lines = output.split("\n");
+    expect(lines.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("returns the text instance", () => {
+    const { theme } = makeMockTheme();
+    const text = new MockText();
+    const details = makeDetails();
+    const context = { state: {}, invalidate: vi.fn() };
+
+    const returned = renderCompactParallel(text, details, theme, context);
+    expect(returned).toBe(text);
+  });
+});
+
+// ── Property tests (fast-check) ────────────────────────────────────────────
+
+describe("buildActivityLine property tests", () => {
+  it("truncated error never exceeds truncLine limit of 80 chars", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 500 }),
+        (error) => {
+          const { theme } = makeMockTheme();
+          const result = buildActivityLine(
+            activityData({ error, status: "running" }),
+            theme,
+          );
+          // Strip the "✗ " prefix and ANSI tags to get the actual truncated text
+          const withoutPrefix = result.replace(/^\[error\]✗ /, "");
+          // The visible text (without closing ANSI tag) should be <= 80
+          const visibleText = withoutPrefix.replace(/\[\/error\]$/, "");
+          expect(visibleText.length).toBeLessThanOrEqual(80);
+        },
+      ),
+    );
+  });
+
+  it("truncated argsPreview never exceeds truncLine limit of 60 chars", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 20 }).filter((s) => !s.includes(": ") && !s.includes("\n") && !s.includes("|")),
+        fc.string({ minLength: 1, maxLength: 500 }).filter((s) => !s.includes(": ") && !s.includes("\n") && !s.includes("|")),
+        (currentTool, currentToolArgs) => {
+          const { theme } = makeMockTheme();
+          const result = buildActivityLine(
+            activityData({ status: "running", currentTool, currentToolArgs }),
+            theme,
+          );
+          // Extract the args portion after ": "
+          const argsMatch = result.match(/: (.+?)(?:\s\|.*|\[\/dim\].*)?$/);
+          expect(argsMatch).not.toBeNull();
+          const argsText = argsMatch![1]!.replace(/\[\/dim\]$/, "").replace(/\[dim\]/, "");
+          expect(argsText.length).toBeLessThanOrEqual(60);
+        },
+      ),
+    );
+  });
+
+  it("truncated finalOutput first line never exceeds truncLine limit of 80 chars", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 500 }),
+        (finalOutput) => {
+          const { theme } = makeMockTheme();
+          const result = buildActivityLine(
+            activityData({ status: "running", finalOutput }),
+            theme,
+          );
+          // Strip ANSI tags to get visible text
+          const visible = result.replace(/\[muted\]/g, "").replace(/\[\/muted\]/g, "");
+          // The visible text after "↳ " should be <= 80
+          const afterArrow = visible.replace(/^↳ /, "");
+          expect(afterArrow.length).toBeLessThanOrEqual(80);
+        },
+      ),
+    );
+  });
+
+  it("truncated string toolCall never exceeds truncLine limit of 60 chars", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 500 }),
+        (toolCallStr) => {
+          const { theme } = makeMockTheme();
+          const result = buildActivityLine(
+            activityData({ status: "running", toolCalls: [toolCallStr] }),
+            theme,
+          );
+          const visible = result.replace(/\[dim\]/g, "").replace(/\[\/dim\]/g, "");
+          const afterArrow = visible.replace(/^↳ /, "");
+          expect(afterArrow.length).toBeLessThanOrEqual(60);
+        },
+      ),
+    );
+  });
+});

package/src/cost.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Events } from "@pi-archimedes/core/bus";
+
+// ── mock bus ────────────────────────────────────────────────────────────────
+
+let mockEmit: ReturnType<typeof vi.fn>;
+
+vi.mock("@pi-archimedes/core/bus", async (importOriginal) => {
+  const actual = await importOriginal() as typeof import("@pi-archimedes/core/bus");
+  return {
+    ...actual,
+    getBus: () => ({
+      emit: mockEmit,
+    }),
+  };
+});
+
+const { emitCostUpdate } = await import("./cost.js");
+
+describe("emitCostUpdate", () => {
+  beforeEach(() => {
+    mockEmit = vi.fn();
+  });
+
+  it("emits COST_UPDATE event with correct source prefix", () => {
+    emitCostUpdate("my-agent", { inputTokens: 100, outputTokens: 50 });
+
+    expect(mockEmit).toHaveBeenCalledWith(Events.COST_UPDATE, {
+      source: "subagent:my-agent",
+      inputTokens: 100,
+      outputTokens: 50,
+    });
+  });
+
+  it("passes through all usage fields", () => {
+    emitCostUpdate("test-agent", {
+      inputTokens: 1000,
+      outputTokens: 500,
+      cacheReadTokens: 200,
+      cacheWriteTokens: 100,
+      cost: 0.05,
+    });
+
+    expect(mockEmit).toHaveBeenCalledWith(Events.COST_UPDATE, {
+      source: "subagent:test-agent",
+      inputTokens: 1000,
+      outputTokens: 500,
+      cacheReadTokens: 200,
+      cacheWriteTokens: 100,
+      cost: 0.05,
+    });
+  });
+
+  it("works with partial usage fields", () => {
+    emitCostUpdate("minimal", { cost: 0.01 });
+
+    expect(mockEmit).toHaveBeenCalledWith(Events.COST_UPDATE, {
+      source: "subagent:minimal",
+      cost: 0.01,
+    });
+  });
+});

package/src/frontmatter-io.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { validateAgentName, serializeAgent, AGENT_NAME_REGEX } from "./frontmatter-io.js";
+import type { AgentConfig } from "./agents.js";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeAgent(overrides: Partial<AgentConfig> = {}): AgentConfig {
+  return {
+    name: "test-agent",
+    description: "A test agent",
+    systemPrompt: "You are a helpful test agent.",
+    source: "user",
+    filePath: "/tmp/test-agent.md",
+    ...overrides,
+  };
+}
+
+// ── validateAgentName ───────────────────────────────────────────────────────
+
+describe("validateAgentName", () => {
+  it("accepts valid names (3-50 chars, lowercase alnum + hyphens)", () => {
+    expect(validateAgentName("abc")).toBeNull();
+    expect(validateAgentName("test-agent")).toBeNull();
+    expect(validateAgentName("a1b2c3")).toBeNull();
+    expect(validateAgentName("my-long-agent-name-with-many-hyphens")).toBeNull();
+  });
+
+  it("accepts single char names", () => {
+    expect(validateAgentName("a")).toBeNull();
+    expect(validateAgentName("z")).toBeNull();
+    expect(validateAgentName("0")).toBeNull();
+    expect(validateAgentName("9")).toBeNull();
+  });
+
+  it("rejects empty string", () => {
+    expect(validateAgentName("")).toBe("Name is required");
+  });
+
+  it("rejects uppercase", () => {
+    expect(validateAgentName("Abc")).not.toBeNull();
+    expect(validateAgentName("ABC")).not.toBeNull();
+  });
+
+  it("rejects special chars", () => {
+    expect(validateAgentName("test_agent")).not.toBeNull();
+    expect(validateAgentName("test.agent")).not.toBeNull();
+    expect(validateAgentName("test agent")).not.toBeNull();
+  });
+
+  it("rejects names starting/ending with hyphens", () => {
+    expect(validateAgentName("-test")).not.toBeNull();
+    expect(validateAgentName("test-")).not.toBeNull();
+  });
+
+  it("rejects two-char names (not single char, not 3+)", () => {
+    expect(validateAgentName("ab")).not.toBeNull();
+  });
+});
+
+// ── serializeAgent ──────────────────────────────────────────────────────────
+
+describe("serializeAgent", () => {
+  it("produces valid YAML frontmatter", () => {
+    const agent = makeAgent();
+    const output = serializeAgent(agent);
+    expect(output).toMatch(/^---\n/);
+    expect(output).toContain("name: test-agent");
+    expect(output).toContain("description: A test agent");
+    expect(output).toContain("You are a helpful test agent.");
+  });
+
+  it("quotes values that need quoting", () => {
+    const agent = makeAgent({ description: "value with: colon" });
+    const output = serializeAgent(agent);
+    expect(output).toContain('description: "value with: colon"');
+  });
+
+  it("includes optional fields when present", () => {
+    const agent = makeAgent({
+      tools: ["read", "write"],
+      model: "gpt-4o",
+      thinking: "high",
+    });
+    const output = serializeAgent(agent);
+    expect(output).toContain("tools: read, write");
+    expect(output).toContain("model: gpt-4o");
+    expect(output).toContain("thinking: high");
+  });
+
+  it("omits optional fields when absent", () => {
+    const agent = makeAgent();
+    const output = serializeAgent(agent);
+    expect(output).not.toContain("tools:");
+    expect(output).not.toContain("model:");
+    expect(output).not.toContain("thinking:");
+  });
+
+  it("property: output starts with '---\\n' and contains closing '\\n---\\n' delimiter", () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1, maxLength: 50 }),
+        fc.string({ minLength: 1, maxLength: 100 }),
+        fc.string({ minLength: 1, maxLength: 200 }),
+        (name, desc, prompt) => {
+          const agent = makeAgent({ name, description: desc, systemPrompt: prompt });
+          const output = serializeAgent(agent);
+          if (!output.startsWith("---\n")) {
+            throw new Error(`Output does not start with '---\\n': ${JSON.stringify(output.slice(0, 20))}`);
+          }
+          if (!output.includes("\n---\n")) {
+            throw new Error(`Output does not contain closing '\\n---\\n' delimiter`);
+          }
+        },
+      ),
+      { verbose: false },
+    );
+  });
+});