@aaroncql/pim-agent 0.0.1 → 0.1.0

package/src/extensions/web-search/ExaMcpClient.test.ts

@@ -1,143 +0,0 @@
-import { expect, test } from "bun:test";
-import { ExaMcpClient } from "./ExaMcpClient";
-
-type MockFetch = (
-  input: Parameters<typeof fetch>[0],
-  init?: Parameters<typeof fetch>[1]
-) => ReturnType<typeof fetch>;
-
-const captureMethod = async (
-  input: Parameters<typeof fetch>[0],
-  init: Parameters<typeof fetch>[1] | undefined
-): Promise<string> => {
-  if (input instanceof Request) {
-    const body = (await input.clone().json()) as { method?: string };
-    return body.method ?? "";
-  }
-  const body = JSON.parse(String(init?.body)) as { method?: string };
-  return body.method ?? "";
-};
-
-const handshakeOr = (toolCallResponse: () => Response): MockFetch => {
-  return async (input, init) => {
-    const method = await captureMethod(input, init);
-
-    if (method === "initialize") {
-      return Response.json(
-        { jsonrpc: "2.0", id: 1, result: {} },
-        { headers: { "mcp-session-id": "session" } }
-      );
-    }
-
-    if (method === "notifications/initialized") {
-      return new Response(null, { status: 202 });
-    }
-
-    return toolCallResponse();
-  };
-};
-
-test("parses Exa JSON results", async () => {
-  const client = new ExaMcpClient({
-    fetch: handshakeOr(() =>
-      Response.json({
-        jsonrpc: "2.0",
-        id: 2,
-        result: {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                results: [
-                  {
-                    title: "Pim docs",
-                    url: "https://example.test/pim",
-                    snippet: "A concise result.",
-                  },
-                ],
-              }),
-            },
-          ],
-        },
-      })
-    ),
-  });
-
-  await expect(
-    client.search({ query: "pim agent", numResults: 3 })
-  ).resolves.toEqual([
-    {
-      title: "Pim docs",
-      url: "https://example.test/pim",
-      snippet: "A concise result.",
-    },
-  ]);
-});
-
-test("parses Exa plain-text result blocks", async () => {
-  const client = new ExaMcpClient({
-    fetch: handshakeOr(() =>
-      Response.json({
-        jsonrpc: "2.0",
-        id: 2,
-        result: {
-          content: [
-            {
-              type: "text",
-              text: [
-                "Title: First text result",
-                "URL: https://example.test/first",
-                "Published: N/A",
-                "Author: N/A",
-                "Highlights:",
-                "First highlighted sentence.",
-                "[...]",
-                "Second highlighted sentence.",
-                "",
-                "---",
-                "",
-                "Title: Second text result",
-                "URL: https://example.test/second",
-                "Highlights:",
-                "Another result.",
-              ].join("\n"),
-            },
-          ],
-        },
-      })
-    ),
-  });
-
-  await expect(
-    client.search({ query: "text result", numResults: 2 })
-  ).resolves.toEqual([
-    {
-      title: "First text result",
-      url: "https://example.test/first",
-      snippet: "First highlighted sentence. Second highlighted sentence.",
-    },
-    {
-      title: "Second text result",
-      url: "https://example.test/second",
-      snippet: "Another result.",
-    },
-  ]);
-});
-
-test("throws clean errors for malformed tool envelopes", async () => {
-  const client = new ExaMcpClient({
-    fetch: handshakeOr(() =>
-      Response.json({
-        jsonrpc: "2.0",
-        id: 2,
-        result: {
-          content: [{ type: "image", url: "https://example.test/image.png" }],
-        },
-      })
-    ),
-  });
-
-  await expect(client.search({ query: "pim", numResults: 1 })).rejects.toThrow(
-    "Exa returned malformed tool content."
-  );
-});

package/src/extensions/web-search/render.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { DEFAULT_NUM_RESULTS } from "./schema";
-import { formatTitle } from "./render";
-
-describe("formatTitle", () => {
-  test("always includes the default count in parentheses", () => {
-    expect(formatTitle("bun release notes", undefined)).toBe(
-      `bun release notes (${DEFAULT_NUM_RESULTS})`
-    );
-  });
-
-  test("includes explicit counts in parentheses", () => {
-    expect(formatTitle("pi agent", 3)).toBe("pi agent (3)");
-  });
-
-  test("uses a placeholder while keeping the count visible", () => {
-    expect(formatTitle(undefined, undefined)).toBe(
-      `... (${DEFAULT_NUM_RESULTS})`
-    );
-  });
-});

package/src/extensions/web-search/search.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { clampNumResults, formatResults } from "./search";
-
-describe("clampNumResults", () => {
-  test("defaults when undefined", () => {
-    expect(clampNumResults(undefined)).toBe(5);
-  });
-
-  test("clamps above maximum", () => {
-    expect(clampNumResults(25)).toBe(10);
-  });
-
-  test("clamps below minimum", () => {
-    expect(clampNumResults(0)).toBe(1);
-  });
-
-  test("passes through valid values", () => {
-    expect(clampNumResults(3)).toBe(3);
-  });
-});
-
-describe("formatResults", () => {
-  test("renders results as deterministic plain text", () => {
-    expect(
-      formatResults([
-        {
-          title: "First",
-          url: "https://example.test/first",
-          snippet: "First snippet.",
-        },
-        {
-          title: "Second",
-          url: "https://example.test/second",
-          snippet: "Second snippet.",
-        },
-      ])
-    ).toBe(
-      [
-        "title: First",
-        "url: https://example.test/first",
-        "snippet: First snippet.",
-        "",
-        "title: Second",
-        "url: https://example.test/second",
-        "snippet: Second snippet.",
-      ].join("\n")
-    );
-  });
-
-  test("returns empty string for empty input", () => {
-    expect(formatResults([])).toBe("");
-  });
-});

package/src/extensions/working-indicator/index.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatElapsed } from "./index";
-
-describe("working indicator formatting", () => {
-  test("formats sub-minute elapsed time", () => {
-    expect(formatElapsed(0)).toBe("0s");
-    expect(formatElapsed(999)).toBe("0s");
-    expect(formatElapsed(32_000)).toBe("32s");
-  });
-
-  test("formats minute elapsed time", () => {
-    expect(formatElapsed(60_000)).toBe("1m 0s");
-    expect(formatElapsed(92_000)).toBe("1m 32s");
-    expect(formatElapsed(3_599_000)).toBe("59m 59s");
-  });
-
-  test("formats hour elapsed time", () => {
-    expect(formatElapsed(3_600_000)).toBe("1h 0m 0s");
-    expect(formatElapsed(3_692_000)).toBe("1h 1m 32s");
-  });
-});

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

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { DiffLines } from "../../shared/DiffLines";
-import { DiffView } from "../../shared/DiffView";
-
-const stubTheme = {
-  fg: (color: string, text: string) => `<${color}>${text}</${color}>`,
-} as unknown as Theme;
-
-describe("DiffView.countStats", () => {
-  test("returns zeros when diff is undefined", () => {
-    expect(DiffView.countStats(undefined)).toEqual({ added: 0, removed: 0 });
-  });
-
-  test("counts added and removed lines across hunks", () => {
-    const diff = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      {
-        lines: ["alpha", "beta", "gamma", "delta"],
-        hasTrailingNewline: true,
-      },
-      {
-        lines: ["alpha", "BETA", "gamma", "DELTA"],
-        hasTrailingNewline: true,
-      },
-      0
-    );
-    expect(DiffView.countStats(diff)).toEqual({ added: 2, removed: 2 });
-  });
-
-  test("counts a brand-new file as all added", () => {
-    const diff = DiffLines.buildToolDiff(
-      "/tmp/new.ts",
-      { lines: [], hasTrailingNewline: false },
-      { lines: ["one", "two", "three"], hasTrailingNewline: true },
-      0
-    );
-    expect(DiffView.countStats(diff)).toEqual({ added: 3, removed: 0 });
-  });
-});
-
-describe("DiffView.formatStats", () => {
-  test("emits both segments separated by a slash", () => {
-    expect(DiffView.formatStats({ added: 5, removed: 2 }, stubTheme)).toBe(
-      "<toolDiffAdded>+5</toolDiffAdded>/<toolDiffRemoved>-2</toolDiffRemoved>"
-    );
-  });
-
-  test("omits the removed segment when zero", () => {
-    expect(DiffView.formatStats({ added: 5, removed: 0 }, stubTheme)).toBe(
-      "<toolDiffAdded>+5</toolDiffAdded>"
-    );
-  });
-
-  test("omits the added segment when zero", () => {
-    expect(DiffView.formatStats({ added: 0, removed: 2 }, stubTheme)).toBe(
-      "<toolDiffRemoved>-2</toolDiffRemoved>"
-    );
-  });
-
-  test("returns empty string when both are zero", () => {
-    expect(DiffView.formatStats({ added: 0, removed: 0 }, stubTheme)).toBe("");
-  });
-});

package/src/extensions/write/write.test.ts

@@ -1,108 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, describe, expect, test } from "bun:test";
-import { writeContent } from "./write";
-
-const tempRoots: string[] = [];
-
-const tempRoot = async (): Promise<string> => {
-  const root = await mkdtemp(join(tmpdir(), "pim-write-tool-"));
-  tempRoots.push(root);
-  return root;
-};
-
-afterAll(async () => {
-  await Promise.all(
-    tempRoots.map((root) => rm(root, { force: true, recursive: true }))
-  );
-});
-
-describe("writeContent", () => {
-  test("creates a new file and reports an all-added diff", async () => {
-    const root = await tempRoot();
-    const path = join(root, "fresh.ts");
-
-    const outcome = await writeContent(path, "alpha\nbeta\n");
-
-    expect(outcome.created).toBe(true);
-    expect(outcome.bytesWritten).toBe(11);
-    expect(await readFile(path, "utf8")).toBe("alpha\nbeta\n");
-    expect(outcome.diff).toBeDefined();
-    const lines = outcome.diff?.hunks[0]?.lines ?? [];
-    expect(lines.map((line) => line.kind)).toEqual(["added", "added"]);
-    expect(lines.map((line) => line.text)).toEqual(["alpha", "beta"]);
-  });
-
-  test("creates parent directories when missing", async () => {
-    const root = await tempRoot();
-    const path = join(root, "deep", "nest", "file.txt");
-
-    const outcome = await writeContent(path, "hello");
-
-    expect(outcome.created).toBe(true);
-    expect(await readFile(path, "utf8")).toBe("hello");
-  });
-
-  test("emits no diff when content is unchanged", async () => {
-    const root = await tempRoot();
-    const path = join(root, "same.txt");
-    await writeFile(path, "alpha\nbeta\n", "utf8");
-
-    const outcome = await writeContent(path, "alpha\nbeta\n");
-
-    expect(outcome.created).toBe(false);
-    expect(outcome.diff).toBeUndefined();
-  });
-
-  test("reports a trailing-newline removal even when content matches and produces no diff hunks", async () => {
-    const root = await tempRoot();
-    const path = join(root, "eof.txt");
-    await writeFile(path, "alpha\n", "utf8");
-
-    const outcome = await writeContent(path, "alpha");
-
-    expect(outcome.created).toBe(false);
-    expect(outcome.diff).toBeUndefined();
-    expect(outcome.trailingNewlineChange).toBe("removed");
-  });
-
-  test("reports a trailing-newline addition", async () => {
-    const root = await tempRoot();
-    const path = join(root, "eof2.txt");
-    await writeFile(path, "alpha", "utf8");
-
-    const outcome = await writeContent(path, "alpha\n");
-
-    expect(outcome.created).toBe(false);
-    expect(outcome.trailingNewlineChange).toBe("added");
-  });
-
-  test("does not report trailing-newline change for newly created files", async () => {
-    const root = await tempRoot();
-    const path = join(root, "fresh.txt");
-
-    const outcome = await writeContent(path, "alpha");
-
-    expect(outcome.created).toBe(true);
-    expect(outcome.trailingNewlineChange).toBeUndefined();
-  });
-
-  test("emits a diff capturing modified lines", async () => {
-    const root = await tempRoot();
-    const path = join(root, "edit.txt");
-    await writeFile(path, "alpha\nbeta\ngamma\n", "utf8");
-
-    const outcome = await writeContent(path, "alpha\nBETA\ngamma\n");
-
-    expect(outcome.created).toBe(false);
-    const lines = outcome.diff?.hunks[0]?.lines ?? [];
-    const kinds = lines.map((line) => line.kind);
-    expect(kinds).toContain("removed");
-    expect(kinds).toContain("added");
-    const removed = lines.find((line) => line.kind === "removed");
-    const added = lines.find((line) => line.kind === "added");
-    expect(removed?.text).toBe("beta");
-    expect(added?.text).toBe("BETA");
-  });
-});

package/src/shared/DiffLines.test.ts

@@ -1,193 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { DiffLines, type ToolDiffSide } from "./DiffLines";
-
-const side = (
-  lines: readonly string[],
-  hasTrailingNewline = true
-): ToolDiffSide => ({
-  lines,
-  hasTrailingNewline,
-});
-
-describe("DiffLines.buildToolDiff", () => {
-  test("returns undefined when content and EOF state are identical", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(["alpha", "beta", "gamma"]),
-      side(["alpha", "beta", "gamma"]),
-      2
-    );
-    expect(result).toBeUndefined();
-  });
-
-  test("captures a single-line modification with surrounding context", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(["alpha", "beta", "gamma"]),
-      side(["alpha", "BETA", "gamma"]),
-      2
-    );
-    expect(result).toBeDefined();
-    const hunk = result?.hunks[0];
-    expect(hunk).toBeDefined();
-    expect(hunk?.lines.map((line) => line.kind)).toEqual([
-      "context",
-      "removed",
-      "added",
-      "context",
-    ]);
-    expect(hunk?.lines.map((line) => line.text)).toEqual([
-      "alpha",
-      "beta",
-      "BETA",
-      "gamma",
-    ]);
-  });
-
-  test("represents an all-added diff for a brand-new file", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/new.ts",
-      side([], false),
-      side(["alpha", "beta"]),
-      2
-    );
-    const hunk = result?.hunks[0];
-    expect(hunk?.lines.map((line) => line.kind)).toEqual(["added", "added"]);
-  });
-
-  test("collapses far-apart changes into separate hunks", () => {
-    const oldLines = Array.from({ length: 20 }, (_, i) => `line ${i + 1}`);
-    const newLines = oldLines.slice();
-    newLines[1] = "EARLY";
-    newLines[18] = "LATE";
-
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(oldLines),
-      side(newLines),
-      1
-    );
-    expect(result?.hunks.length).toBe(2);
-  });
-
-  test("attaches intra-line emphasis to a paired removed/added line", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(["const x = 1;"]),
-      side(["const y = 2;"]),
-      1
-    );
-    const lines = result?.hunks[0]?.lines ?? [];
-    const removed = lines.find((line) => line.kind === "removed");
-    const added = lines.find((line) => line.kind === "added");
-
-    expect(removed?.emphasis?.length ?? 0).toBeGreaterThan(0);
-    expect(added?.emphasis?.length ?? 0).toBeGreaterThan(0);
-
-    for (const range of removed?.emphasis ?? []) {
-      const slice = removed?.text.slice(range.start, range.end) ?? "";
-      expect(slice.includes("x") || slice.includes("1")).toBe(true);
-    }
-  });
-
-  test("skips emphasis when removed and added runs are unequal length", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(["alpha"]),
-      side(["beta", "gamma"]),
-      1
-    );
-    const lines = result?.hunks[0]?.lines ?? [];
-
-    for (const line of lines) {
-      expect(line.emphasis).toBeUndefined();
-    }
-  });
-
-  test("does not emphasize leading whitespace", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(["  foo();"]),
-      side(["    foo();"]),
-      1
-    );
-    const lines = result?.hunks[0]?.lines ?? [];
-
-    for (const line of lines) {
-      for (const range of line.emphasis ?? []) {
-        const slice = line.text.slice(range.start, range.end);
-        expect(/^\s/.test(slice)).toBe(false);
-      }
-    }
-  });
-
-  test("skips emphasis when lines share no content", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(["foo"]),
-      side(["bar"]),
-      1
-    );
-    const lines = result?.hunks[0]?.lines ?? [];
-
-    for (const line of lines) {
-      expect(line.emphasis).toBeUndefined();
-    }
-  });
-
-  test("returns undefined when only EOF newline state differs (callers surface EOF themselves)", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(["alpha"], true),
-      side(["alpha"], false),
-      2
-    );
-    expect(result).toBeUndefined();
-  });
-
-  test("does not emit a phantom empty added line when appending to a newline-terminated file", () => {
-    const result = DiffLines.buildToolDiff(
-      "/tmp/x.ts",
-      side(["foo", "bar"], true),
-      side(["foo", "bar", "baz"], true),
-      1
-    );
-    const lines = result?.hunks[0]?.lines ?? [];
-    const added = lines.filter((line) => line.kind === "added");
-    expect(added).toHaveLength(1);
-    expect(added[0]?.text).toBe("baz");
-  });
-
-  test("throws on negative contextSize", () => {
-    expect(() =>
-      DiffLines.buildToolDiff("/tmp/x.ts", side(["a"]), side(["b"]), -1)
-    ).toThrow();
-  });
-});
-
-describe("DiffLines.fromText", () => {
-  test("treats the empty string as zero lines, no trailing newline", () => {
-    expect(DiffLines.fromText("")).toEqual({
-      lines: [],
-      hasTrailingNewline: false,
-    });
-  });
-
-  test("distinguishes 'a' from 'a\\n'", () => {
-    expect(DiffLines.fromText("a")).toEqual({
-      lines: ["a"],
-      hasTrailingNewline: false,
-    });
-    expect(DiffLines.fromText("a\n")).toEqual({
-      lines: ["a"],
-      hasTrailingNewline: true,
-    });
-  });
-
-  test("preserves embedded blank lines without collapsing them", () => {
-    expect(DiffLines.fromText("a\n\nb\n")).toEqual({
-      lines: ["a", "", "b"],
-      hasTrailingNewline: true,
-    });
-  });
-});