@aaroncql/pim-agent 0.0.1 → 0.1.0

package/src/extensions/todo/index.test.ts

@@ -1,244 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-  Theme,
-} from "@earendil-works/pi-coding-agent";
-import type { TodoItem } from "./schema";
-import registerTodo from "./index";
-import { getCurrentItems } from "./todo";
-
-type Handler = (event: unknown, ctx: ExtensionContext) => unknown;
-type RegisteredTool = {
-  readonly executionMode?: string;
-  readonly execute: (...args: readonly unknown[]) => unknown;
-};
-type AppendedEntry = {
-  readonly customType: string;
-  readonly data: unknown;
-};
-type SentMessage = {
-  readonly message: unknown;
-  readonly options: unknown;
-};
-type MockPi = {
-  readonly api: ExtensionAPI;
-  readonly handlers: Map<string, Handler[]>;
-  readonly tools: RegisteredTool[];
-  readonly appendedEntries: AppendedEntry[];
-  readonly sentMessages: SentMessage[];
-};
-type WidgetUpdate = {
-  readonly id: string;
-  readonly lines: readonly string[] | undefined;
-};
-
-type MockContext = ExtensionContext & {
-  readonly widgetUpdates: WidgetUpdate[];
-};
-
-const stubTheme = {
-  fg: (color: string, text: string) => `<${color}>${text}</${color}>`,
-  bold: (text: string) => `**${text}**`,
-  strikethrough: (text: string) => `~~${text}~~`,
-} as unknown as Theme;
-
-describe("todo extension", () => {
-  test("clears an all-done widget on the next user input", async () => {
-    const pi = createPi();
-    const ctx = createContext();
-    registerTodo(pi.api);
-
-    await setTodos(pi, ctx, [
-      { content: "Ship it", status: "completed" },
-      { content: "Skip obsolete", status: "cancelled" },
-    ]);
-    await emit(pi, "turn_end", { type: "turn_end" }, ctx);
-    await flush();
-
-    expect(ctx.widgetUpdates.at(-1)?.lines).toEqual([
-      "**2 todos** (1 done, 1 cancelled)",
-      "<success>✔</success> <muted>Ship it</muted>",
-      "<muted>✘</muted> <muted>~~Skip obsolete~~</muted>",
-    ]);
-
-    const results = await emit(pi, "input", { type: "input" }, ctx);
-
-    expect(results).toEqual([{ action: "continue" }]);
-    expect(getCurrentItems(ctx.sessionManager)).toEqual([]);
-    expect(ctx.widgetUpdates.at(-1)).toEqual({
-      id: "pim-todo",
-      lines: undefined,
-    });
-  });
-
-  test("keeps the widget when any todo is still active", async () => {
-    const pi = createPi();
-    const ctx = createContext();
-    registerTodo(pi.api);
-
-    const todos: readonly TodoItem[] = [
-      { content: "Done", status: "completed" },
-      { content: "Next", status: "pending" },
-    ];
-    await setTodos(pi, ctx, todos);
-    await emit(pi, "turn_end", { type: "turn_end" }, ctx);
-    await flush();
-    const updatesBeforeInput = ctx.widgetUpdates.length;
-
-    const results = await emit(pi, "input", { type: "input" }, ctx);
-
-    expect(results).toEqual([{ action: "continue" }]);
-    expect(getCurrentItems(ctx.sessionManager)).toEqual(todos);
-    expect(ctx.widgetUpdates).toHaveLength(updatesBeforeInput);
-  });
-
-  test("checkpoints todo state on session_compact so the widget survives a reload", async () => {
-    const pi = createPi();
-    const ctx = createContext();
-    registerTodo(pi.api);
-
-    const todos: readonly TodoItem[] = [
-      { content: "Ship", status: "in_progress" },
-      { content: "Verify", status: "pending" },
-    ];
-    await setTodos(pi, ctx, todos);
-    await emit(pi, "session_compact", { type: "session_compact" }, ctx);
-
-    expect(pi.appendedEntries).toEqual([
-      { customType: "pim-todo-state", data: { todos } },
-    ]);
-    expect(pi.sentMessages).toEqual([
-      {
-        message: {
-          customType: "pim-todo-snapshot",
-          content: "Current todo list:\n[>] Ship\n[ ] Verify",
-          display: false,
-        },
-        options: { triggerTurn: false },
-      },
-    ]);
-  });
-
-  test("session_compact is a no-op when there are no items", async () => {
-    const pi = createPi();
-    const ctx = createContext();
-    registerTodo(pi.api);
-
-    await emit(pi, "session_compact", { type: "session_compact" }, ctx);
-
-    expect(pi.appendedEntries).toEqual([]);
-    expect(pi.sentMessages).toEqual([]);
-  });
-
-  test("subagent ctx mutating todos does not leak into the parent ctx", async () => {
-    const pi = createPi();
-    const parent = createContext();
-    const child = createContext();
-    registerTodo(pi.api);
-
-    await setTodos(pi, parent, [{ content: "parent", status: "pending" }]);
-    await setTodos(pi, child, [{ content: "child", status: "in_progress" }]);
-
-    expect(getCurrentItems(parent.sessionManager)).toEqual([
-      { content: "parent", status: "pending" },
-    ]);
-    expect(getCurrentItems(child.sessionManager)).toEqual([
-      { content: "child", status: "in_progress" },
-    ]);
-  });
-
-  test("todo tool executes sequentially and returns a compact update summary", async () => {
-    const pi = createPi();
-    const ctx = createContext();
-    registerTodo(pi.api);
-
-    expect(pi.tools[0]?.executionMode).toBe("sequential");
-    expect(await setTodos(pi, ctx, [])).toEqual({
-      content: [
-        {
-          type: "text",
-          text: "Todos cleared.",
-        },
-      ],
-      details: {
-        todos: [],
-        summary: {
-          pending: 0,
-          in_progress: 0,
-          completed: 0,
-          cancelled: 0,
-        },
-      },
-    });
-  });
-});
-
-function createPi(): MockPi {
-  const handlers = new Map<string, Handler[]>();
-  const tools: RegisteredTool[] = [];
-  const appendedEntries: AppendedEntry[] = [];
-  const sentMessages: SentMessage[] = [];
-  const api = {
-    on(event: string, handler: Handler): void {
-      const existing = handlers.get(event) ?? [];
-      existing.push(handler);
-      handlers.set(event, existing);
-    },
-    registerTool(tool: RegisteredTool): void {
-      tools.push(tool);
-    },
-    appendEntry(customType: string, data: unknown): void {
-      appendedEntries.push({ customType, data });
-    },
-    sendMessage(message: unknown, options: unknown): void {
-      sentMessages.push({ message, options });
-    },
-  } as unknown as ExtensionAPI;
-
-  return { api, handlers, tools, appendedEntries, sentMessages };
-}
-
-function createContext(): MockContext {
-  const widgetUpdates: WidgetUpdate[] = [];
-  return {
-    hasUI: true,
-    sessionManager: {},
-    ui: {
-      theme: stubTheme,
-      setWidget(id: string, lines: readonly string[] | undefined): void {
-        widgetUpdates.push({ id, lines });
-      },
-    },
-    widgetUpdates,
-  } as unknown as MockContext;
-}
-
-async function emit(
-  pi: MockPi,
-  event: string,
-  payload: unknown,
-  ctx: ExtensionContext
-): Promise<unknown[]> {
-  const results: unknown[] = [];
-  for (const handler of pi.handlers.get(event) ?? []) {
-    results.push(await handler(payload, ctx));
-  }
-  return results;
-}
-
-function flush(): Promise<void> {
-  return new Promise((resolve) => setImmediate(resolve));
-}
-
-async function setTodos(
-  pi: MockPi,
-  ctx: ExtensionContext,
-  todos: readonly TodoItem[]
-): Promise<unknown> {
-  const tool = pi.tools[0];
-  if (!tool) {
-    throw new Error("todo tool was not registered");
-  }
-  return await tool.execute("todo-call", { todos }, undefined, undefined, ctx);
-}

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

@@ -1,180 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  AgentToolResult,
-  Theme,
-  ToolRenderResultOptions,
-} from "@earendil-works/pi-coding-agent";
-import type { TodoItem } from "./schema";
-import {
-  formatCallTitle,
-  formatWidgetTitle,
-  renderCall,
-  renderResult,
-  renderWidgetLines,
-} from "./render";
-import { makeDetails } from "./todo";
-
-const items: readonly TodoItem[] = [
-  { content: "Plan", status: "pending" },
-  { content: "Build", status: "in_progress" },
-  { content: "Verify", status: "completed" },
-  { content: "Skip", status: "cancelled" },
-];
-
-const stubTheme = {
-  fg: (color: string, text: string) => `<${color}>${text}</${color}>`,
-  bold: (text: string) => `**${text}**`,
-  strikethrough: (text: string) => `~~${text}~~`,
-} as unknown as Theme;
-
-const expandedOptions = {
-  expanded: true,
-  isPartial: false,
-} as ToolRenderResultOptions;
-const context = {
-  lastComponent: undefined,
-  isPartial: false,
-  isError: false,
-};
-
-describe("todo render", () => {
-  test("renderCall shows only the compact status summary", () => {
-    expect(formatCallTitle(items)).toBe("1 done, 2 pending, 1 cancelled");
-    const rendered = renderCall({ todos: items }, stubTheme, context).render(
-      120
-    )[0];
-    expect(rendered).toContain("**Todo**");
-    expect(rendered).toContain("1 done, 2 pending, 1 cancelled");
-  });
-
-  test("renderCall shows cleared when the todo list is empty", () => {
-    expect(formatCallTitle([])).toBe("cleared");
-    const rendered = renderCall({ todos: [] }, stubTheme, context).render(
-      120
-    )[0];
-
-    expect(rendered).toContain("**Todo**");
-    expect(rendered).toContain(": cleared");
-  });
-
-  test("renderResult is hidden so the widget is the only TUI checklist", () => {
-    expect(
-      renderResult(
-        toolResult(items),
-        expandedOptions,
-        stubTheme,
-        context
-      ).render(120)
-    ).toEqual([]);
-  });
-
-  test("widget title bolds total and wraps status summary", () => {
-    const pendingItems: readonly TodoItem[] = [
-      { content: "One", status: "pending" },
-      { content: "Two", status: "pending" },
-      { content: "Three", status: "pending" },
-      { content: "Four", status: "pending" },
-    ];
-
-    expect(formatWidgetTitle(pendingItems, stubTheme)).toBe(
-      "**4 todos** (4 pending)"
-    );
-  });
-
-  test("widget colours only status markers", () => {
-    const lines = renderWidgetLines(items, stubTheme);
-
-    expect(formatWidgetTitle(items, stubTheme)).toBe(
-      "**4 todos** (1 done, 2 pending, 1 cancelled)"
-    );
-    expect(lines).toEqual([
-      "**4 todos** (1 done, 2 pending, 1 cancelled)",
-      "□ Plan",
-      "<warning>➤</warning> **Build**",
-      "<success>✔</success> <muted>Verify</muted>",
-      "<muted>✘</muted> <muted>~~Skip~~</muted>",
-    ]);
-  });
-
-  test("widget shows all rows instead of trading one todo for a +1 hint", () => {
-    const many = makePendingItems(6);
-
-    const lines = renderWidgetLines(many, stubTheme);
-
-    expect(lines).toHaveLength(7);
-    expect(lines.slice(1)).toEqual([
-      "□ Task 1",
-      "□ Task 2",
-      "□ Task 3",
-      "□ Task 4",
-      "□ Task 5",
-      "□ Task 6",
-    ]);
-  });
-
-  test("widget caps rows with a muted hidden-count hint", () => {
-    const many = makePendingItems(10);
-
-    const lines = renderWidgetLines(many, stubTheme);
-
-    expect(lines).toHaveLength(7);
-    expect(lines.slice(1, -1)).toEqual([
-      "□ Task 1",
-      "□ Task 2",
-      "□ Task 3",
-      "□ Task 4",
-      "□ Task 5",
-    ]);
-    expect(lines.at(-1)).toBe("<muted>… +5 more</muted>");
-  });
-
-  test("widget centers the visible rows around the in-progress item", () => {
-    const many = makePendingItems(50, { index: 24, status: "in_progress" });
-
-    const lines = renderWidgetLines(many, stubTheme);
-
-    expect(lines).toHaveLength(7);
-    expect(lines.slice(1, -1)).toEqual([
-      "□ Task 23",
-      "□ Task 24",
-      "<warning>➤</warning> **Task 25**",
-      "□ Task 26",
-      "□ Task 27",
-    ]);
-    expect(lines.at(-1)).toBe("<muted>… +45 more</muted>");
-  });
-
-  test("widget falls back to the last non-pending item when none are in progress", () => {
-    const many = makePendingItems(12, { index: 6, status: "completed" });
-
-    const lines = renderWidgetLines(many, stubTheme);
-
-    expect(lines.slice(1, -1)).toEqual([
-      "□ Task 5",
-      "□ Task 6",
-      "<success>✔</success> <muted>Task 7</muted>",
-      "□ Task 8",
-      "□ Task 9",
-    ]);
-    expect(lines.at(-1)).toBe("<muted>… +7 more</muted>");
-  });
-});
-
-function toolResult(
-  items: readonly TodoItem[]
-): AgentToolResult<ReturnType<typeof makeDetails>> {
-  return {
-    content: [{ type: "text", text: "" }],
-    details: makeDetails(items),
-  };
-}
-
-function makePendingItems(
-  count: number,
-  override?: { readonly index: number; readonly status: TodoItem["status"] }
-): readonly TodoItem[] {
-  return Array.from({ length: count }, (_, index) => ({
-    content: `Task ${index + 1}`,
-    status: override?.index === index ? override.status : "pending",
-  }));
-}

package/src/extensions/todo/todo.test.ts

@@ -1,222 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { TodoItem } from "./schema";
-import {
-  formatChecklist,
-  formatUpdateSummary,
-  getCurrentItems,
-  hasActiveItems,
-  makeDetails,
-  normalizeItems,
-  reconstructFromBranch,
-  replaceItems,
-  summarizeItems,
-  type TodoSessionKey,
-} from "./todo";
-
-const allStatuses: readonly TodoItem[] = [
-  { content: "Plan", status: "pending" },
-  { content: "Build", status: "in_progress" },
-  { content: "Verify", status: "completed" },
-  { content: "Skip obsolete step", status: "cancelled" },
-];
-
-function fakeSession(): TodoSessionKey {
-  return {} as TodoSessionKey;
-}
-
-describe("todo state", () => {
-  test("replace semantics keep the latest write only", () => {
-    const sm = fakeSession();
-    replaceItems(sm, [
-      { content: "a", status: "pending" },
-      { content: "b", status: "pending" },
-      { content: "c", status: "pending" },
-    ]);
-    const latest = replaceItems(sm, [{ content: "d", status: "in_progress" }]);
-
-    expect(latest).toEqual([{ content: "d", status: "in_progress" }]);
-    expect(formatChecklist(getCurrentItems(sm))).toBe("[>] d");
-  });
-
-  test("state is isolated between sessions (parent vs subagent)", () => {
-    const parent = fakeSession();
-    const child = fakeSession();
-    replaceItems(parent, [{ content: "parent task", status: "pending" }]);
-    replaceItems(child, [{ content: "child task", status: "in_progress" }]);
-
-    expect(getCurrentItems(parent)).toEqual([
-      { content: "parent task", status: "pending" },
-    ]);
-    expect(getCurrentItems(child)).toEqual([
-      { content: "child task", status: "in_progress" },
-    ]);
-  });
-
-  test("content is normalized to a single trimmed line and blank content is dropped", () => {
-    expect(
-      normalizeItems([
-        { content: "", status: "pending" },
-        { content: "   ", status: "in_progress" },
-        { content: "  keep\nthis\titem  ", status: "completed" },
-      ])
-    ).toEqual([{ content: "keep this item", status: "completed" }]);
-  });
-
-  test("multiple in_progress items are accepted as-is", () => {
-    const items = normalizeItems([
-      { content: "one", status: "in_progress" },
-      { content: "two", status: "in_progress" },
-    ]);
-
-    expect(formatChecklist(items)).toBe("[>] one\n[>] two");
-  });
-
-  test("duplicate content strings are accepted", () => {
-    const items = normalizeItems([
-      { content: "repeat", status: "pending" },
-      { content: "repeat", status: "completed" },
-    ]);
-
-    expect(items).toEqual([
-      { content: "repeat", status: "pending" },
-      { content: "repeat", status: "completed" },
-    ]);
-  });
-
-  test("active-only checklist drops completed and cancelled", () => {
-    expect(formatChecklist(allStatuses, { activeOnly: true })).toBe(
-      "[ ] Plan\n[>] Build"
-    );
-    expect(
-      formatChecklist(
-        [
-          { content: "done", status: "completed" },
-          { content: "skipped", status: "cancelled" },
-        ],
-        { activeOnly: true }
-      )
-    ).toBe("");
-  });
-
-  test("active item detection treats pending and in-progress as active", () => {
-    expect(hasActiveItems(allStatuses)).toBe(true);
-    expect(
-      hasActiveItems([
-        { content: "done", status: "completed" },
-        { content: "skipped", status: "cancelled" },
-      ])
-    ).toBe(false);
-  });
-
-  test("full checklist includes all marker styles", () => {
-    expect(formatChecklist(allStatuses)).toBe(
-      ["[ ] Plan", "[>] Build", "[x] Verify", "[~] Skip obsolete step"].join(
-        "\n"
-      )
-    );
-  });
-
-  test("reconstruction finds the most recent todo tool result", () => {
-    const branch = [
-      toolResult("todo", [{ content: "old", status: "pending" }]),
-      toolResult("grep", [{ content: "ignored", status: "completed" }]),
-      toolResult("todo", [{ content: "new", status: "in_progress" }]),
-    ];
-
-    expect(reconstructFromBranch(fakeSession(), branch)).toEqual([
-      { content: "new", status: "in_progress" },
-    ]);
-  });
-
-  test("reconstruction restores from a pim-todo-state checkpoint after compaction", () => {
-    const branch = [
-      { type: "compaction", summary: "old todos summarized away" },
-      todoStateEntry([{ content: "kept", status: "in_progress" }]),
-    ];
-
-    expect(reconstructFromBranch(fakeSession(), branch)).toEqual([
-      { content: "kept", status: "in_progress" },
-    ]);
-  });
-
-  test("reconstruction prefers a later tool result over an older checkpoint", () => {
-    const branch = [
-      todoStateEntry([{ content: "old", status: "pending" }]),
-      toolResult("todo", [{ content: "new", status: "completed" }]),
-    ];
-
-    expect(reconstructFromBranch(fakeSession(), branch)).toEqual([
-      { content: "new", status: "completed" },
-    ]);
-  });
-
-  test("reconstruction prefers a later checkpoint over an older tool result", () => {
-    const branch = [
-      toolResult("todo", [{ content: "old", status: "pending" }]),
-      todoStateEntry([{ content: "checkpointed", status: "in_progress" }]),
-    ];
-
-    expect(reconstructFromBranch(fakeSession(), branch)).toEqual([
-      { content: "checkpointed", status: "in_progress" },
-    ]);
-  });
-
-  test("update summary formats model-visible acknowledgement", () => {
-    expect(
-      formatUpdateSummary([
-        { content: "one", status: "completed" },
-        { content: "two", status: "completed" },
-        { content: "three", status: "in_progress" },
-        { content: "four", status: "pending" },
-        { content: "five", status: "pending" },
-      ])
-    ).toBe("Todos updated: 2 completed, 1 in progress, 2 pending.");
-  });
-
-  test("update summary omits zero counts and includes cancelled only when nonzero", () => {
-    expect(formatUpdateSummary(allStatuses)).toBe(
-      "Todos updated: 1 completed, 1 in progress, 1 pending, 1 cancelled."
-    );
-    expect(formatUpdateSummary([{ content: "next", status: "pending" }])).toBe(
-      "Todos updated: 1 pending."
-    );
-  });
-
-  test("update summary handles a cleared list", () => {
-    expect(formatUpdateSummary([])).toBe("Todos cleared.");
-  });
-
-  test("summary counts statuses", () => {
-    expect(summarizeItems(allStatuses)).toEqual({
-      pending: 1,
-      in_progress: 1,
-      completed: 1,
-      cancelled: 1,
-    });
-    expect(makeDetails(allStatuses).summary).toEqual({
-      pending: 1,
-      in_progress: 1,
-      completed: 1,
-      cancelled: 1,
-    });
-  });
-});
-
-function toolResult(toolName: string, todos: readonly TodoItem[]): unknown {
-  return {
-    type: "message",
-    message: {
-      role: "toolResult",
-      toolName,
-      details: { todos },
-    },
-  };
-}
-
-function todoStateEntry(todos: readonly TodoItem[]): unknown {
-  return {
-    type: "custom",
-    customType: "pim-todo-state",
-    data: { todos },
-  };
-}