@aaroncql/pim-agent 0.0.1 → 0.2.0

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

@@ -1,254 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { PimSettings } from "../../shared/PimSettings";
-import registerTps from "./index";
-
-type Handler = (event: unknown, ctx: unknown) => unknown;
-
-type MockPi = {
-  readonly api: ExtensionAPI;
-  readonly handlers: Map<string, Handler[]>;
-};
-
-const originalNow = Date.now;
-const originalGet = PimSettings.get;
-
-let now = 0;
-
-function createPi(): MockPi {
-  const handlers = new Map<string, Handler[]>();
-  const api = {
-    on(event: string, handler: Handler): void {
-      const existing = handlers.get(event) ?? [];
-      existing.push(handler);
-      handlers.set(event, existing);
-    },
-    registerCommand(): void {},
-  } as unknown as ExtensionAPI;
-
-  return { api, handlers };
-}
-
-async function emit(
-  pi: MockPi,
-  event: string,
-  payload: unknown,
-  ctx: unknown
-): Promise<void> {
-  for (const handler of pi.handlers.get(event) ?? []) {
-    await handler(payload, ctx);
-  }
-}
-
-const assistantMessage = {
-  role: "assistant",
-  content: [{ type: "text", text: "hello" }],
-  api: "openai",
-  provider: "openai",
-  model: "test-model",
-  usage: {
-    input: 1000,
-    output: 50,
-    cacheRead: 5000,
-    cacheWrite: 100,
-    totalTokens: 6150,
-    cost: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      total: 0,
-    },
-  },
-  stopReason: "stop",
-  timestamp: 1000,
-} as const;
-
-describe("tps extension", () => {
-  beforeEach(() => {
-    now = 0;
-    Date.now = () => now;
-    Object.defineProperty(PimSettings, "get", {
-      value: async () => ({ enabled: true }),
-    });
-  });
-
-  afterEach(() => {
-    Date.now = originalNow;
-    Object.defineProperty(PimSettings, "get", { value: originalGet });
-  });
-
-  test("reports metrics when stream updates and final message are different objects", async () => {
-    const pi = createPi();
-    const notifications: string[] = [];
-    const ctx = {
-      hasUI: true,
-      ui: {
-        notify(message: string): void {
-          notifications.push(message);
-        },
-      },
-    };
-
-    registerTps(pi.api);
-
-    await emit(pi, "agent_start", { type: "agent_start" }, ctx);
-
-    now = 1000;
-    await emit(
-      pi,
-      "before_provider_request",
-      { type: "before_provider_request", payload: {} },
-      ctx
-    );
-
-    now = 1150;
-    await emit(
-      pi,
-      "message_update",
-      {
-        type: "message_update",
-        message: { ...assistantMessage },
-        assistantMessageEvent: {
-          type: "text_start",
-          contentIndex: 0,
-          partial: assistantMessage,
-        },
-      },
-      ctx
-    );
-
-    now = 1200;
-    await emit(
-      pi,
-      "message_update",
-      {
-        type: "message_update",
-        message: { ...assistantMessage },
-        assistantMessageEvent: {
-          type: "text_delta",
-          contentIndex: 0,
-          delta: "h",
-          partial: assistantMessage,
-        },
-      },
-      ctx
-    );
-
-    now = 2200;
-    await emit(
-      pi,
-      "message_end",
-      { type: "message_end", message: assistantMessage },
-      ctx
-    );
-    await emit(
-      pi,
-      "agent_end",
-      { type: "agent_end", messages: [assistantMessage] },
-      ctx
-    );
-
-    expect(notifications).toEqual([
-      "Decode: 50.0 tps | Prefill: 5500.0 tps | Cache read: 5,000 | TTFT: 0.20s",
-    ]);
-  });
-
-  test("reports once at the end of a multi-turn agent cycle", async () => {
-    const pi = createPi();
-    const notifications: string[] = [];
-    const ctx = {
-      hasUI: true,
-      ui: {
-        notify(message: string): void {
-          notifications.push(message);
-        },
-      },
-    };
-
-    registerTps(pi.api);
-
-    await emit(pi, "agent_start", { type: "agent_start" }, ctx);
-
-    now = 1000;
-    await emit(
-      pi,
-      "before_provider_request",
-      { type: "before_provider_request", payload: {} },
-      ctx
-    );
-    now = 1200;
-    await emit(
-      pi,
-      "message_update",
-      {
-        type: "message_update",
-        message: { ...assistantMessage },
-        assistantMessageEvent: {
-          type: "thinking_delta",
-          contentIndex: 0,
-          delta: "thinking",
-          partial: assistantMessage,
-        },
-      },
-      ctx
-    );
-    now = 2200;
-    await emit(
-      pi,
-      "message_end",
-      { type: "message_end", message: assistantMessage },
-      ctx
-    );
-    await emit(
-      pi,
-      "turn_end",
-      { type: "turn_end", message: assistantMessage, toolResults: [] },
-      ctx
-    );
-
-    now = 3000;
-    await emit(
-      pi,
-      "before_provider_request",
-      { type: "before_provider_request", payload: {} },
-      ctx
-    );
-    now = 3200;
-    await emit(
-      pi,
-      "message_update",
-      {
-        type: "message_update",
-        message: { ...assistantMessage },
-        assistantMessageEvent: {
-          type: "text_delta",
-          contentIndex: 0,
-          delta: "h",
-          partial: assistantMessage,
-        },
-      },
-      ctx
-    );
-    now = 4200;
-    await emit(
-      pi,
-      "message_end",
-      { type: "message_end", message: assistantMessage },
-      ctx
-    );
-
-    expect(notifications).toEqual([]);
-
-    await emit(
-      pi,
-      "agent_end",
-      { type: "agent_end", messages: [assistantMessage, assistantMessage] },
-      ctx
-    );
-
-    expect(notifications).toEqual([
-      "Decode: 50.0 tps | Prefill: 5500.0 tps | Cache read: 10,000 | TTFT: 0.20s",
-    ]);
-  });
-});

package/src/extensions/web-fetch/WebViewMarkdownSnapshot.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  createMarkdownSnapshotScript,
-  renderMarkdownSnapshotTree,
-  type MarkdownSnapshotElementNode,
-  type MarkdownSnapshotNode,
-} from "./WebViewMarkdownSnapshot";
-
-const text = (value: string): MarkdownSnapshotNode => ({
-  type: "text",
-  text: value,
-});
-
-const element = (
-  tagName: string,
-  children: readonly MarkdownSnapshotNode[] = [],
-  options: Partial<MarkdownSnapshotElementNode> = {}
-): MarkdownSnapshotElementNode => ({
-  type: "element",
-  tagName,
-  children,
-  ...options,
-});
-
-describe("createMarkdownSnapshotScript", () => {
-  test("builds a parseable browser snapshot script from stringified functions", () => {
-    const script = createMarkdownSnapshotScript();
-
-    expect(script).toStartWith("(function captureMarkdownSnapshot");
-    expect(script).toContain("function renderMarkdownSnapshotTree");
-    expect(script).toContain("function serializeNode");
-    expect(script).not.toContain("const renderMarkdownSnapshotTree =");
-    expect(() => new Function(script)).not.toThrow();
-  });
-});
-
-describe("renderMarkdownSnapshotTree", () => {
-  test("renders headings, inline formatting, code, and absolute links", () => {
-    const root = element("body", [
-      element("h1", [text("Hello")]),
-      element("p", [
-        text("Read "),
-        element("strong", [text("docs")]),
-        text(" at "),
-        element("a", [text("guide")], {
-          attributes: [{ name: "href", value: "/guide" }],
-        }),
-        text(" with "),
-        element("code", [text("x")], { textContent: "x" }),
-      ]),
-    ]);
-
-    expect(renderMarkdownSnapshotTree(root, "https://example.test/base/")).toBe(
-      [
-        "# Hello",
-        "",
-        "Read **docs** at [guide](https://example.test/guide) with `x`",
-      ].join("\n")
-    );
-  });
-
-  test("renders lists, blockquotes, tables, and fenced code blocks", () => {
-    const root = element("body", [
-      element("ul", [
-        element("li", [text("one")]),
-        element("li", [text("two")]),
-      ]),
-      element("blockquote", [element("p", [text("quoted")])]),
-      element("table", [
-        element("tbody", [
-          element("tr", [
-            element("th", [text("Name")]),
-            element("th", [text("Value")]),
-          ]),
-          element("tr", [
-            element("td", [text("A|B")]),
-            element("td", [text("2")]),
-          ]),
-        ]),
-      ]),
-      element("pre", [element("code", [text("const x = 1;")])], {
-        textContent: "const x = 1;",
-      }),
-    ]);
-
-    expect(renderMarkdownSnapshotTree(root, "https://example.test/")).toBe(
-      [
-        "- one",
-        "- two",
-        "",
-        "> quoted",
-        "",
-        "| Name | Value |",
-        "| --- | --- |",
-        "| A\\|B | 2 |",
-        "",
-        "```",
-        "const x = 1;",
-        "```",
-      ].join("\n")
-    );
-  });
-
-  test("skips hidden content and unsafe links", () => {
-    const root = element("body", [
-      element("p", [
-        text("shown"),
-        element("span", [text("hidden")], { ariaHidden: "true" }),
-        element("a", [text("unsafe")], {
-          attributes: [{ name: "href", value: "javascript:alert(1)" }],
-        }),
-      ]),
-    ]);
-
-    expect(renderMarkdownSnapshotTree(root, "https://example.test/")).toBe(
-      "shown unsafe"
-    );
-  });
-});

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

@@ -1,244 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { SpillCache } from "../../shared/SpillCache";
-import {
-  executeFetch,
-  formatOutcome,
-  truncationFooter,
-  validatePublicUrl,
-} from "./fetch";
-import { WEB_FETCH_INLINE_BYTES } from "./schema";
-import type { JinaReaderClient } from "./JinaReaderClient";
-import type { WebViewFetchClient } from "./WebViewFetchClient";
-
-let previousPimHomeDir: string | undefined;
-let testPimHomeDir: string | undefined;
-
-beforeAll(async () => {
-  previousPimHomeDir = process.env.PIM_HOME_DIR;
-  testPimHomeDir = await mkdtemp(join(tmpdir(), "pim-fetch-home-"));
-  process.env.PIM_HOME_DIR = testPimHomeDir;
-});
-
-afterAll(async () => {
-  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("validatePublicUrl", () => {
-  test("accepts http and https", () => {
-    expect(validatePublicUrl("https://example.com/path")).toBe(
-      "https://example.com/path"
-    );
-    expect(validatePublicUrl("http://example.com")).toBe("http://example.com/");
-  });
-
-  test("rejects non-http schemes", () => {
-    expect(() => validatePublicUrl("ftp://example.com")).toThrow(/http/);
-    expect(() => validatePublicUrl("file:///etc/passwd")).toThrow(/http/);
-  });
-
-  test("rejects malformed URLs", () => {
-    expect(() => validatePublicUrl("not a url")).toThrow(/valid/);
-  });
-
-  test("rejects embedded credentials", () => {
-    expect(() => validatePublicUrl("https://user:pw@example.com")).toThrow(
-      /credentials/
-    );
-  });
-
-  test("rejects localhost and .local", () => {
-    expect(() => validatePublicUrl("http://localhost/")).toThrow(/public/);
-    expect(() => validatePublicUrl("http://printer.local/")).toThrow(/public/);
-  });
-
-  test("rejects RFC1918 IPv4", () => {
-    expect(() => validatePublicUrl("http://10.0.0.1/")).toThrow(/public/);
-    expect(() => validatePublicUrl("http://192.168.1.1/")).toThrow(/public/);
-    expect(() => validatePublicUrl("http://172.16.0.1/")).toThrow(/public/);
-    expect(() => validatePublicUrl("http://127.0.0.1/")).toThrow(/public/);
-    expect(() => validatePublicUrl("http://169.254.0.1/")).toThrow(/public/);
-  });
-
-  test("rejects IPv6 loopback and link-local", () => {
-    expect(() => validatePublicUrl("http://[::1]/")).toThrow(/public/);
-    expect(() => validatePublicUrl("http://[fe80::1]/")).toThrow(/public/);
-    expect(() => validatePublicUrl("http://[fc00::1]/")).toThrow(/public/);
-  });
-
-  test("accepts public IPs", () => {
-    expect(validatePublicUrl("http://8.8.8.8/")).toBe("http://8.8.8.8/");
-  });
-});
-
-describe("executeFetch", () => {
-  test("returns remote markdown when available", async () => {
-    const jina = {
-      fetchUrl: async () => ({
-        title: "Remote",
-        url: "https://example.test/remote",
-        content: "remote markdown",
-      }),
-    } as unknown as JinaReaderClient;
-    const webView = {
-      fetchMarkdown: async () => {
-        throw new Error("Rendered markdown should not be attempted.");
-      },
-    } as unknown as WebViewFetchClient;
-
-    const outcome = await executeFetch({
-      jina,
-      webView,
-      url: "https://example.test/",
-      format: "markdown",
-    });
-
-    expect(outcome.format).toBe("markdown");
-    expect(outcome.text).toContain("remote markdown");
-  });
-
-  test("falls back to rendered markdown when remote markdown fails", async () => {
-    const jina = {
-      fetchUrl: async () => {
-        throw new Error("Request timed out after 20000ms.");
-      },
-    } as unknown as JinaReaderClient;
-    const webView = {
-      fetchMarkdown: async () => ({
-        title: "Rendered",
-        url: "https://example.test/rendered",
-        content: "# rendered markdown",
-      }),
-      fetchHtml: async () => {
-        throw new Error("HTML should not be attempted for markdown mode.");
-      },
-    } as unknown as WebViewFetchClient;
-
-    const outcome = await executeFetch({
-      jina,
-      webView,
-      url: "https://example.test/",
-      format: "markdown",
-    });
-
-    expect(outcome.format).toBe("markdown");
-    expect(outcome.text).toContain("# rendered markdown");
-  });
-
-  test("throws rendered markdown error when fallback fails", async () => {
-    const jina = {
-      fetchUrl: async () => {
-        throw new Error("remote unavailable");
-      },
-    } as unknown as JinaReaderClient;
-    const webView = {
-      fetchMarkdown: async () => {
-        throw new Error("Request failed: unavailable");
-      },
-    } as unknown as WebViewFetchClient;
-
-    await expect(
-      executeFetch({
-        jina,
-        webView,
-        url: "https://example.test/",
-        format: "markdown",
-      })
-    ).rejects.toThrow("Failed to fetch: Request failed: unavailable");
-  });
-
-  test("returns raw rendered HTML for HTML mode", async () => {
-    const jina = {
-      fetchUrl: async () => {
-        throw new Error("Remote markdown should not be attempted.");
-      },
-    } as unknown as JinaReaderClient;
-    const webView = {
-      fetchHtml: async () => ({
-        title: "HTML",
-        url: "https://example.test/html",
-        content: "<html><body>Hello</body></html>",
-      }),
-    } as unknown as WebViewFetchClient;
-
-    const outcome = await executeFetch({
-      jina,
-      webView,
-      url: "https://example.test/",
-      format: "html",
-    });
-
-    expect(outcome.format).toBe("html");
-    expect(outcome.text).toContain("<html><body>Hello</body></html>");
-  });
-});
-
-describe("formatOutcome", () => {
-  const page = {
-    title: "Example",
-    url: "https://example.test/page",
-    content: "hello world",
-  };
-
-  test("formats untruncated page without spilling", async () => {
-    const outcome = await formatOutcome(page, "markdown");
-    expect(outcome.text).toBe(
-      [
-        "title: Example",
-        "url: https://example.test/page",
-        "format: markdown",
-        "content:",
-        "hello world",
-      ].join("\n")
-    );
-    expect(outcome.truncated).toBe(false);
-    expect(outcome.returnedBytes).toBe(11);
-    expect(outcome.totalBytes).toBe(11);
-    expect(outcome.format).toBe("markdown");
-    expect(outcome.path).toBeNull();
-  });
-
-  test("spills the full body and points the footer at the resume line over the inline budget", async () => {
-    // 1 KiB newline-terminated lines: the 32 KiB head holds exactly 32 lines,
-    // so the footer should resume reading at line 33.
-    const line = `${"x".repeat(1023)}\n`;
-    const content = line.repeat(40);
-    const long = { ...page, content };
-    const outcome = await formatOutcome(long, "html");
-    expect(outcome.truncated).toBe(true);
-    expect(outcome.returnedBytes).toBe(WEB_FETCH_INLINE_BYTES);
-    expect(outcome.totalBytes).toBe(content.length);
-    expect(outcome.path).toBeTruthy();
-    expect(outcome.path!.startsWith(join(SpillCache.dir(), "fetch-"))).toBe(
-      true
-    );
-    expect(outcome.path!.endsWith(".html")).toBe(true);
-    expect(outcome.text).toContain(
-      `use read with path=${outcome.path} and start=33 for the rest.]`
-    );
-    expect(await Bun.file(outcome.path!).text()).toBe(content);
-  });
-});
-
-describe("truncationFooter", () => {
-  test("points at the spill file with a resume line when one was written", () => {
-    expect(truncationFooter(100, 2000, "/tmp/pim/cache/fetch-abc.md", 7)).toBe(
-      "[web_fetch tool: showing first 100 bytes of 2000; use read with path=/tmp/pim/cache/fetch-abc.md and start=7 for the rest.]"
-    );
-  });
-
-  test("signals the rest is unavailable when the spill failed", () => {
-    expect(truncationFooter(100, 2000, null, 7)).toBe(
-      "[web_fetch tool: showing first 100 bytes of 2000; full content unavailable.]"
-    );
-  });
-});

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

@@ -1,56 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatTitle } from "./render";
-
-describe("formatTitle", () => {
-  test("returns placeholder and default format when url is undefined", () => {
-    expect(formatTitle(undefined, undefined, undefined)).toBe("... (Markdown)");
-  });
-
-  test("renders default markdown pre-result", () => {
-    expect(formatTitle("https://example.com", undefined, undefined)).toBe(
-      "https://example.com (Markdown)"
-    );
-  });
-
-  test("renders requested HTML pre-result", () => {
-    expect(formatTitle("https://example.com", "html", undefined)).toBe(
-      "https://example.com (HTML)"
-    );
-  });
-
-  test("renders size + format label after result arrives", () => {
-    expect(
-      formatTitle("https://example.com", undefined, {
-        format: "markdown",
-        totalBytes: 23 * 1024,
-      })
-    ).toBe("https://example.com (23KB Markdown)");
-  });
-
-  test("strips trailing zeros and supports two decimals", () => {
-    expect(
-      formatTitle("https://example.com", undefined, {
-        format: "html",
-        totalBytes: 5355,
-      })
-    ).toBe("https://example.com (5.23KB HTML)");
-  });
-
-  test("renders bytes for tiny payloads", () => {
-    expect(
-      formatTitle("https://example.com", undefined, {
-        format: "markdown",
-        totalBytes: 512,
-      })
-    ).toBe("https://example.com (512B Markdown)");
-  });
-
-  test("renders MB for large payloads", () => {
-    expect(
-      formatTitle("https://example.com", undefined, {
-        format: "html",
-        totalBytes: 2.5 * 1024 * 1024,
-      })
-    ).toBe("https://example.com (2.5MB HTML)");
-  });
-});