@aaroncql/pim-agent 0.0.1 → 0.1.0

package/src/shared/McpClient.test.ts

@@ -1,235 +0,0 @@
-import { expect, test } from "bun:test";
-import { McpClient } from "./McpClient";
-
-type MockFetch = (
-  input: Parameters<typeof fetch>[0],
-  init?: Parameters<typeof fetch>[1]
-) => ReturnType<typeof fetch>;
-
-type CapturedRequest = {
-  readonly url: string;
-  readonly headers: Headers;
-  readonly body: Readonly<Record<string, unknown>>;
-};
-
-const captureRequest = async (
-  input: Parameters<typeof fetch>[0],
-  init: Parameters<typeof fetch>[1] | undefined
-): Promise<CapturedRequest> => {
-  if (input instanceof Request) {
-    const text = await input.clone().text();
-
-    return {
-      url: input.url,
-      headers: input.headers,
-      body: JSON.parse(text) as Readonly<Record<string, unknown>>,
-    };
-  }
-
-  return {
-    url: String(input),
-    headers: new Headers(init?.headers),
-    body: JSON.parse(String(init?.body)) as Readonly<Record<string, unknown>>,
-  };
-};
-
-const okToolCallResponse = (result: unknown): Response =>
-  Response.json({ jsonrpc: "2.0", id: 2, result });
-
-test("performs the initialize → initialized → tools/call round trip", async () => {
-  const requests: CapturedRequest[] = [];
-  const fetcher: MockFetch = async (input, init) => {
-    const request = await captureRequest(input, init);
-    requests.push(request);
-
-    if (request.body["method"] === "initialize") {
-      return Response.json(
-        { jsonrpc: "2.0", id: 1, result: {} },
-        { headers: { "mcp-session-id": "session-json" } }
-      );
-    }
-
-    if (request.body["method"] === "notifications/initialized") {
-      return new Response(null, { status: 202 });
-    }
-
-    return okToolCallResponse({ ok: true });
-  };
-  const client = new McpClient({
-    endpoint: "https://mcp.test/mcp",
-    headers: { "x-api-key": "test-key" },
-    fetch: fetcher,
-  });
-
-  await expect(
-    client.callTool({ name: "demo_tool", arguments: { x: 1 } })
-  ).resolves.toEqual({ ok: true });
-
-  expect(requests.map((request) => request.url)).toEqual([
-    "https://mcp.test/mcp",
-    "https://mcp.test/mcp",
-    "https://mcp.test/mcp",
-  ]);
-  expect(requests[1]?.headers.get("mcp-session-id")).toBe("session-json");
-  expect(requests[2]?.headers.get("mcp-session-id")).toBe("session-json");
-  expect(requests[0]?.headers.get("x-api-key")).toBe("test-key");
-  for (const request of requests) {
-    expect(request.headers.get("mcp-protocol-version")).toBe("2025-06-18");
-  }
-  expect(requests[0]?.body).toEqual({
-    jsonrpc: "2.0",
-    id: 1,
-    method: "initialize",
-    params: {
-      protocolVersion: "2025-06-18",
-      clientInfo: {
-        name: "pim-agent",
-        version: "0.0.0",
-      },
-      capabilities: {},
-    },
-  });
-  expect(requests[2]?.body).toEqual({
-    jsonrpc: "2.0",
-    id: 2,
-    method: "tools/call",
-    params: {
-      name: "demo_tool",
-      arguments: { x: 1 },
-    },
-  });
-});
-
-test("parses SSE responses", async () => {
-  const ssePayload = [
-    "event: message",
-    `data: ${JSON.stringify({
-      jsonrpc: "2.0",
-      id: 2,
-      result: { ok: true },
-    })}`,
-    "",
-    "",
-  ].join("\n");
-  const fetcher: MockFetch = async (input, init) => {
-    const request = await captureRequest(input, init);
-
-    if (request.body["method"] === "initialize") {
-      return Response.json(
-        { jsonrpc: "2.0", id: 1, result: {} },
-        { headers: { "mcp-session-id": "session-sse" } }
-      );
-    }
-
-    if (request.body["method"] === "notifications/initialized") {
-      return new Response(null, { status: 202 });
-    }
-
-    return new Response(ssePayload, {
-      headers: { "content-type": "text/event-stream" },
-    });
-  };
-  const client = new McpClient({
-    endpoint: "https://mcp.test/mcp",
-    fetch: fetcher,
-  });
-
-  await expect(
-    client.callTool({ name: "demo_tool", arguments: {} })
-  ).resolves.toEqual({ ok: true });
-});
-
-test("throws clean errors for HTTP failures", async () => {
-  const fetcher: MockFetch = async () =>
-    new Response("upstream unavailable and not useful beyond this excerpt", {
-      status: 503,
-    });
-  const client = new McpClient({
-    endpoint: "https://mcp.test/mcp",
-    fetch: fetcher,
-  });
-
-  await expect(
-    client.callTool({ name: "demo_tool", arguments: {} })
-  ).rejects.toThrow("MCP request failed with HTTP 503: upstream unavailable");
-});
-
-test("throws clean errors for JSON-RPC failures", async () => {
-  const fetcher: MockFetch = async (input, init) => {
-    const request = await captureRequest(input, init);
-
-    if (request.body["method"] === "initialize") {
-      return Response.json(
-        { jsonrpc: "2.0", id: 1, result: {} },
-        { headers: { "mcp-session-id": "session-error" } }
-      );
-    }
-
-    if (request.body["method"] === "notifications/initialized") {
-      return new Response(null, { status: 202 });
-    }
-
-    return Response.json({
-      jsonrpc: "2.0",
-      id: 2,
-      error: { code: -32602, message: "Invalid input." },
-    });
-  };
-  const client = new McpClient({
-    endpoint: "https://mcp.test/mcp",
-    fetch: fetcher,
-  });
-
-  await expect(
-    client.callTool({ name: "demo_tool", arguments: {} })
-  ).rejects.toThrow("MCP JSON-RPC error: Invalid input.");
-});
-
-test("sends cancellation notification on aborted calls", async () => {
-  const abortController = new AbortController();
-  const requests: CapturedRequest[] = [];
-  const fetcher: MockFetch = async (input, init) => {
-    const request = await captureRequest(input, init);
-    requests.push(request);
-
-    if (request.body["method"] === "initialize") {
-      return Response.json(
-        { jsonrpc: "2.0", id: 1, result: {} },
-        { headers: { "mcp-session-id": "session-abort" } }
-      );
-    }
-
-    if (request.body["method"] === "notifications/initialized") {
-      return new Response(null, { status: 202 });
-    }
-
-    if (request.body["method"] === "tools/call") {
-      abortController.abort();
-      throw new DOMException("Aborted", "AbortError");
-    }
-
-    return new Response(null, { status: 202 });
-  };
-  const client = new McpClient({
-    endpoint: "https://mcp.test/mcp",
-    fetch: fetcher,
-  });
-
-  await expect(
-    client.callTool({
-      name: "demo_tool",
-      arguments: {},
-      signal: abortController.signal,
-    })
-  ).rejects.toThrow("MCP request aborted.");
-
-  expect(requests.at(-1)?.body).toEqual({
-    jsonrpc: "2.0",
-    method: "notifications/cancelled",
-    params: {
-      requestId: 2,
-      reason: "Tool call aborted.",
-    },
-  });
-  expect(requests.at(-1)?.headers.get("mcp-session-id")).toBe("session-abort");
-});

package/src/shared/OutputBudget.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { OutputBudget } from "./OutputBudget";
-
-describe("truncateLine", () => {
-  test("returns lines under the cap untouched", () => {
-    expect(OutputBudget.truncateLine("short")).toBe("short");
-  });
-
-  test("truncates with a signposted suffix once over the cap", () => {
-    const line = "x".repeat(OutputBudget.maxLineLength + 50);
-    expect(OutputBudget.truncateLine(line)).toBe(
-      `${"x".repeat(OutputBudget.maxLineLength)}... (line truncated to ${OutputBudget.maxLineLength} chars)`
-    );
-  });
-});
-
-describe("truncateUtf8", () => {
-  test("returns content unchanged when under cap", () => {
-    const result = OutputBudget.truncateUtf8("hello", 1024);
-    expect(result.body).toBe("hello");
-    expect(result.truncated).toBe(false);
-    expect(result.totalBytes).toBe(5);
-    expect(result.returnedBytes).toBe(5);
-  });
-
-  test("truncates ASCII at exact byte boundary", () => {
-    const result = OutputBudget.truncateUtf8("a".repeat(100), 10);
-    expect(result.body).toBe("a".repeat(10));
-    expect(result.truncated).toBe(true);
-    expect(result.returnedBytes).toBe(10);
-    expect(result.totalBytes).toBe(100);
-  });
-
-  test("backs off to a UTF-8 boundary mid-codepoint", () => {
-    const result = OutputBudget.truncateUtf8("é", 1);
-    expect(result.body).toBe("");
-    expect(result.returnedBytes).toBe(0);
-    expect(result.truncated).toBe(true);
-    expect(result.totalBytes).toBe(2);
-  });
-
-  test("preserves complete multi-byte chars", () => {
-    const result = OutputBudget.truncateUtf8("héllo", 3);
-    expect(result.body).toBe("hé");
-    expect(result.returnedBytes).toBe(3);
-    expect(result.truncated).toBe(true);
-    expect(result.totalBytes).toBe(6);
-  });
-
-  test("backs off across a 4-byte sequence", () => {
-    const result = OutputBudget.truncateUtf8("🦀x", 2);
-    expect(result.body).toBe("");
-    expect(result.returnedBytes).toBe(0);
-    expect(result.truncated).toBe(true);
-  });
-
-  test("defaults to OutputBudget.maxBytes when no cap supplied", () => {
-    const content = "a".repeat(OutputBudget.maxBytes + 100);
-    const result = OutputBudget.truncateUtf8(content);
-    expect(result.body.length).toBe(OutputBudget.maxBytes);
-    expect(result.truncated).toBe(true);
-  });
-});
-
-describe("applyByteCap", () => {
-  test("returns all items when their joined length fits", () => {
-    const items = ["alpha", "beta", "gamma"];
-    const result = OutputBudget.applyByteCap(items);
-    expect(result.visible).toEqual(items);
-    expect(result.droppedItems).toBe(0);
-  });
-
-  test("drops trailing items past the byte cap", () => {
-    const item = "x".repeat(100);
-    const items = Array.from({ length: 20 }, () => item);
-    const result = OutputBudget.applyByteCap(items, { maxBytes: 250 });
-    // 100 + 1 + 100 = 201 fits, adding another 1 + 100 = 302 does not.
-    expect(result.visible).toHaveLength(2);
-    expect(result.droppedItems).toBe(18);
-  });
-
-  test("always includes the first item even when it overflows alone", () => {
-    const head = "x".repeat(500);
-    const result = OutputBudget.applyByteCap([head, "tail"], {
-      maxBytes: 100,
-    });
-    expect(result.visible).toEqual([head]);
-    expect(result.droppedItems).toBe(1);
-  });
-
-  test("respects a custom separator", () => {
-    // Two 5-byte items with a 10-byte separator: 5 + 10 + 5 = 20.
-    const result = OutputBudget.applyByteCap(["alpha", "betas"], {
-      maxBytes: 20,
-      separator: "----------",
-    });
-    expect(result.visible).toEqual(["alpha", "betas"]);
-  });
-});

package/src/shared/Paths.test.ts

@@ -1,51 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, test } from "bun:test";
-import { Paths } from "./Paths";
-
-describe("Paths.resolve", () => {
-  test("resolves relative paths against base", () => {
-    expect(Paths.resolve("foo.txt", "/work")).toBe("/work/foo.txt");
-    expect(Paths.resolve("src/foo.ts", "/work")).toBe("/work/src/foo.ts");
-  });
-
-  test("expands ~ to home directory", () => {
-    const home = homedir();
-    expect(Paths.resolve("~", "/tmp")).toBe(home);
-    expect(Paths.resolve("~/.config", "/tmp")).toBe(join(home, ".config"));
-  });
-
-  test("preserves absolute paths", () => {
-    expect(Paths.resolve("/etc/hosts", "/tmp")).toBe("/etc/hosts");
-  });
-});
-
-describe("Paths.displayRelative", () => {
-  test("returns relative path when inside cwd", () => {
-    expect(Paths.displayRelative("/work/src/foo.ts", "/work")).toBe(
-      "src/foo.ts"
-    );
-  });
-
-  test("returns absolute path when outside cwd", () => {
-    expect(Paths.displayRelative("/etc/hosts", "/work")).toBe("/etc/hosts");
-  });
-
-  test("returns absolute path when cwd equals path", () => {
-    expect(Paths.displayRelative("/work", "/work")).toBe("/work");
-  });
-});
-
-describe("Paths.titleOr", () => {
-  test("returns the placeholder when path is undefined", () => {
-    expect(Paths.titleOr(undefined, "/work")).toBe("...");
-  });
-
-  test("returns a path relative to cwd when within cwd", () => {
-    expect(Paths.titleOr("/work/src/file.ts", "/work")).toBe("src/file.ts");
-  });
-
-  test("returns the absolute path when outside cwd", () => {
-    expect(Paths.titleOr("/other/file.ts", "/work")).toBe("/other/file.ts");
-  });
-});

package/src/shared/PimSettings.test.ts

@@ -1,90 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtemp, rm, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { PimSettings } from "./PimSettings";
-
-let previousExaApiKey: string | undefined;
-let previousJinaApiKey: string | undefined;
-let previousPimHomeDir: string | undefined;
-let testPimHomeDir: string | undefined;
-
-beforeAll(async () => {
-  previousExaApiKey = process.env.EXA_API_KEY;
-  previousJinaApiKey = process.env.JINA_API_KEY;
-  previousPimHomeDir = process.env.PIM_HOME_DIR;
-  testPimHomeDir = await mkdtemp(join(tmpdir(), "pim-settings-home-"));
-  delete process.env.EXA_API_KEY;
-  delete process.env.JINA_API_KEY;
-  process.env.PIM_HOME_DIR = testPimHomeDir;
-});
-
-afterAll(async () => {
-  if (previousExaApiKey === undefined) {
-    delete process.env.EXA_API_KEY;
-  } else {
-    process.env.EXA_API_KEY = previousExaApiKey;
-  }
-  if (previousJinaApiKey === undefined) {
-    delete process.env.JINA_API_KEY;
-  } else {
-    process.env.JINA_API_KEY = previousJinaApiKey;
-  }
-  if (previousPimHomeDir === undefined) {
-    delete process.env.PIM_HOME_DIR;
-  } else {
-    process.env.PIM_HOME_DIR = previousPimHomeDir;
-  }
-  if (testPimHomeDir) {
-    await rm(testPimHomeDir, { recursive: true, force: true });
-  }
-});
-
-describe("PimSettings", () => {
-  test("loads defaults from ~/.pim/settings.json", async () => {
-    expect(PimSettings.path()).toBe(join(testPimHomeDir!, "settings.json"));
-    await expect(PimSettings.get("tps")).resolves.toEqual({ enabled: false });
-    await expect(PimSettings.get("powerline")).resolves.toEqual({
-      enabled: true,
-    });
-    await expect(PimSettings.get("exa")).resolves.toEqual({});
-    await expect(PimSettings.get("jina")).resolves.toEqual({});
-  });
-
-  test("writes settings with private directory and file modes", async () => {
-    await PimSettings.set("exa", { apiKey: "exa-test" });
-    await PimSettings.set("jina", { apiKey: "jina-test" });
-
-    const path = PimSettings.path();
-    expect(path).toBe(join(testPimHomeDir!, "settings.json"));
-    expect(await Bun.file(path).json()).toEqual({
-      tps: { enabled: false },
-      powerline: { enabled: true },
-      exa: { apiKey: "exa-test" },
-      jina: { apiKey: "jina-test" },
-    });
-
-    expect((await stat(testPimHomeDir!)).mode & 0o777).toBe(0o700);
-    expect((await stat(path)).mode & 0o777).toBe(0o600);
-  });
-
-  test("resolves API keys from env vars before settings", async () => {
-    await PimSettings.set("exa", { apiKey: "exa-test" });
-    await PimSettings.set("jina", { apiKey: "jina-test" });
-
-    await expect(PimSettings.getExaApiKey()).resolves.toBe("exa-test");
-    await expect(PimSettings.getJinaApiKey()).resolves.toBe("jina-test");
-
-    process.env.EXA_API_KEY = "  exa-env  ";
-    process.env.JINA_API_KEY = "";
-
-    await expect(PimSettings.getExaApiKey()).resolves.toBe("exa-env");
-    await expect(PimSettings.getJinaApiKey()).resolves.toBe("jina-test");
-  });
-
-  test("rejects invalid root setting values", async () => {
-    await expect(
-      PimSettings.set("exa", { apiKey: 123 } as never)
-    ).rejects.toThrow('Invalid value for pim setting "exa"');
-  });
-});

package/src/shared/Renderer.test.ts

@@ -1,190 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  AgentToolResult,
-  Theme,
-  ThemeColor,
-  ToolRenderResultOptions,
-} from "@earendil-works/pi-coding-agent";
-import { visibleWidth } from "@earendil-works/pi-tui";
-import { Renderer } from "./Renderer";
-
-const stubTheme = {
-  bold: (text: string) => text,
-  fg: (_color: string, text: string) => text,
-} as unknown as Theme;
-
-function tracingTheme(): {
-  readonly theme: Theme;
-  readonly calls: { readonly color: ThemeColor; readonly text: string }[];
-} {
-  const calls: { color: ThemeColor; text: string }[] = [];
-  return {
-    calls,
-    theme: {
-      bold: (text: string) => text,
-      fg: (color: ThemeColor, text: string) => {
-        calls.push({ color, text });
-        return text;
-      },
-    } as unknown as Theme,
-  };
-}
-
-const expandedOptions = {
-  expanded: true,
-  isPartial: false,
-} satisfies ToolRenderResultOptions;
-
-const rendererContext = {
-  lastComponent: undefined,
-  isPartial: false,
-  isError: false,
-} as const;
-
-function textResult(text: string): AgentToolResult<unknown> {
-  return { content: [{ type: "text", text }], details: undefined };
-}
-
-describe("Renderer.markerColorFor", () => {
-  test("partial wins over error", () => {
-    expect(Renderer.markerColorFor(true, true)).toBe("warning");
-  });
-  test("error when not partial", () => {
-    expect(Renderer.markerColorFor(false, true)).toBe("error");
-  });
-  test("success otherwise", () => {
-    expect(Renderer.markerColorFor(false, false)).toBe("success");
-  });
-});
-
-describe("Renderer.buildPreviewLines", () => {
-  test("returns body unchanged when within limit", () => {
-    expect(Renderer.buildPreviewLines("a\nb\nc", 5)).toEqual({
-      preview: "a\nb\nc",
-      overflow: 0,
-    });
-  });
-  test("truncates and reports overflow", () => {
-    const body = "1\n2\n3\n4\n5\n6\n7";
-    expect(Renderer.buildPreviewLines(body, 3)).toEqual({
-      preview: "1\n2\n3",
-      overflow: 4,
-    });
-  });
-  test("limit equal to line count is not truncated", () => {
-    expect(Renderer.buildPreviewLines("a\nb\nc", 3)).toEqual({
-      preview: "a\nb\nc",
-      overflow: 0,
-    });
-  });
-});
-
-describe("Renderer.renderBorderedResult", () => {
-  test("wraps expanded output by default", () => {
-    const component = Renderer.renderBorderedResult({
-      result: textResult("0123456789abcdef\nnext"),
-      options: expandedOptions,
-      theme: stubTheme,
-      context: rendererContext,
-      previewLines: 10,
-    });
-
-    expect(component.render(10)).toHaveLength(4);
-  });
-
-  test("expanded output includes all lines even beyond the preview limit", () => {
-    const component = Renderer.renderBorderedResult({
-      result: textResult(
-        [
-          "  src/file.ts:10:before",
-          "> src/file.ts:11:matched",
-          "  src/file.ts:12:after",
-        ].join("\n")
-      ),
-      options: expandedOptions,
-      theme: stubTheme,
-      context: rendererContext,
-      previewLines: 1,
-    });
-
-    expect(component.render(80)).toEqual([
-      " │   src/file.ts:10:before",
-      " │ > src/file.ts:11:matched",
-      " │   src/file.ts:12:after",
-    ]);
-  });
-});
-
-describe("Renderer.renderToolCallTitle", () => {
-  test("leaves single-line titles unbordered", () => {
-    const component = Renderer.renderToolCallTitle({
-      label: "Bash",
-      title: "pwd",
-      theme: stubTheme,
-      context: {
-        lastComponent: undefined,
-        isPartial: false,
-        isError: false,
-      },
-    });
-
-    expect(component.render(80)).toEqual([" ▪ Bash: pwd".padEnd(80, " ")]);
-  });
-
-  test("labelColor overrides the default label color when provided", () => {
-    const overridden = tracingTheme();
-    Renderer.renderToolCallTitle({
-      label: "Subagent",
-      title: "investigate",
-      theme: overridden.theme,
-      context: {
-        lastComponent: undefined,
-        isPartial: false,
-        isError: false,
-      },
-      labelColor: "accent",
-    }).render(80);
-
-    expect(overridden.calls).toContainEqual({
-      color: "accent",
-      text: "Subagent",
-    });
-    expect(overridden.calls).not.toContainEqual({
-      color: "toolTitle",
-      text: "Subagent",
-    });
-
-    const fallback = tracingTheme();
-    Renderer.renderToolCallTitle({
-      label: "Bash",
-      title: "pwd",
-      theme: fallback.theme,
-      context: {
-        lastComponent: undefined,
-        isPartial: false,
-        isError: false,
-      },
-    }).render(80);
-
-    expect(fallback.calls).toContainEqual({ color: "toolTitle", text: "Bash" });
-  });
-
-  test("adds a left border to wrapped title lines", () => {
-    const width = 18;
-    const component = Renderer.renderToolCallTitle({
-      label: "Bash",
-      title: "one two three four five six seven",
-      theme: stubTheme,
-      context: {
-        lastComponent: undefined,
-        isPartial: false,
-        isError: false,
-      },
-    });
-    const lines = component.render(width);
-
-    expect(lines.length).toBeGreaterThan(1);
-    expect(lines.slice(1).every((line) => line.startsWith(" │ "))).toBe(true);
-    expect(lines.every((line) => visibleWidth(line) <= width)).toBe(true);
-  });
-});