terramend 0.2.0

package/src/utils/body.test.ts

@@ -0,0 +1,217 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PayloadEvent } from "#app/external";
+import { resolveBody, resolveBodyAssets } from "#app/utils/body";
+import type { OctokitWithPlugins } from "#app/utils/github";
+import type { RunContextData } from "#app/utils/runContextData";
+
+vi.mock("#app/utils/assets", () => ({
+  // echo the markdown back with a marker so call-through is observable
+  downloadAssetsInMarkdown: vi.fn(async (markdown: string) => `downloaded:${markdown}`),
+}));
+
+import { downloadAssetsInMarkdown } from "#app/utils/assets";
+
+const downloadMock = vi.mocked(downloadAssetsInMarkdown);
+
+const repo = { owner: "acme", name: "infra" } as RunContextData["repo"];
+
+function makeOctokit() {
+  const issuesGetComment = vi.fn(async () => ({ data: { body_html: "<p>comment html</p>" } }));
+  const issuesGet = vi.fn(async () => ({ data: { body_html: "<p>issue html</p>" } }));
+  const pullsGetReview = vi.fn(async () => ({ data: { body_html: "<p>review html</p>" } }));
+  const pullsGetReviewComment = vi.fn(async () => ({
+    data: { body_html: "<p>review comment html</p>" },
+  }));
+  const octokit = {
+    rest: {
+      issues: { getComment: issuesGetComment, get: issuesGet },
+      pulls: { getReview: pullsGetReview, getReviewComment: pullsGetReviewComment },
+    },
+  } as unknown as OctokitWithPlugins;
+  return { octokit, issuesGetComment, issuesGet, pullsGetReview, pullsGetReviewComment };
+}
+
+function ctxFor(event: Record<string, unknown>, octokit: OctokitWithPlugins) {
+  return {
+    event: event as unknown as PayloadEvent,
+    octokit,
+    repo,
+    tmpdir: "/tmp/run",
+    githubToken: "tok",
+  };
+}
+
+const IMG_BODY = "look: ![shot](https://github.com/user-attachments/assets/abc)";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("resolveBodyAssets", () => {
+  it("returns null for a missing body", async () => {
+    await expect(
+      resolveBodyAssets({ body: null, bodyHtml: undefined, tmpdir: "/t", githubToken: "x" }),
+    ).resolves.toBeNull();
+    await expect(
+      resolveBodyAssets({ body: undefined, bodyHtml: "<p>hi</p>", tmpdir: "/t", githubToken: "x" }),
+    ).resolves.toBeNull();
+    expect(downloadMock).not.toHaveBeenCalled();
+  });
+
+  it("downloads assets for a plain markdown body without conversion", async () => {
+    const result = await resolveBodyAssets({
+      body: "no images here",
+      bodyHtml: "<p>ignored</p>",
+      tmpdir: "/t",
+      githubToken: "x",
+    });
+    expect(result).toBe("downloaded:no images here");
+    expect(downloadMock).toHaveBeenCalledWith("no images here", "/t", "x");
+  });
+
+  it("converts body_html to markdown when the body has images", async () => {
+    const result = await resolveBodyAssets({
+      body: IMG_BODY,
+      bodyHtml: '<p>see <img src="https://signed.example/img.png" alt="shot"></p>',
+      tmpdir: "/t",
+      githubToken: "x",
+    });
+    expect(result).toContain("downloaded:");
+    expect(result).toContain("https://signed.example/img.png");
+    expect(result).not.toContain("user-attachments");
+  });
+
+  it("keeps the raw body when it has images but no rendered html", async () => {
+    const result = await resolveBodyAssets({
+      body: IMG_BODY,
+      bodyHtml: undefined,
+      tmpdir: "/t",
+      githubToken: "x",
+    });
+    expect(result).toBe(`downloaded:${IMG_BODY}`);
+  });
+});
+
+describe("resolveBody", () => {
+  it("does not fetch body_html when the body has no images", async () => {
+    const { octokit, issuesGet, issuesGetComment } = makeOctokit();
+    const result = await resolveBody(
+      ctxFor({ trigger: "issues_opened", issue_number: 3, body: "plain text" }, octokit),
+    );
+    expect(result).toBe("downloaded:plain text");
+    expect(issuesGet).not.toHaveBeenCalled();
+    expect(issuesGetComment).not.toHaveBeenCalled();
+  });
+
+  it("fetches comment html for issue_comment_created", async () => {
+    const { octokit, issuesGetComment } = makeOctokit();
+    const result = await resolveBody(
+      ctxFor({ trigger: "issue_comment_created", comment_id: 11, body: IMG_BODY }, octokit),
+    );
+    expect(issuesGetComment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        owner: "acme",
+        repo: "infra",
+        comment_id: 11,
+        headers: { accept: "application/vnd.github.full+json" },
+      }),
+    );
+    expect(result).toBe("downloaded:comment html");
+  });
+
+  it("returns undefined html when issue_comment_created lacks a comment id", async () => {
+    const { octokit, issuesGetComment } = makeOctokit();
+    const result = await resolveBody(
+      ctxFor({ trigger: "issue_comment_created", body: IMG_BODY }, octokit),
+    );
+    expect(issuesGetComment).not.toHaveBeenCalled();
+    expect(result).toBe(`downloaded:${IMG_BODY}`);
+  });
+
+  it.each([
+    "issues_opened",
+    "issues_assigned",
+    "issues_labeled",
+  ])("fetches the issue html for %s", async (trigger) => {
+    const { octokit, issuesGet } = makeOctokit();
+    const result = await resolveBody(ctxFor({ trigger, issue_number: 5, body: IMG_BODY }, octokit));
+    expect(issuesGet).toHaveBeenCalledWith(expect.objectContaining({ issue_number: 5 }));
+    expect(result).toBe("downloaded:issue html");
+  });
+
+  it.each([
+    "pull_request_opened",
+    "pull_request_ready_for_review",
+    "pull_request_synchronize",
+    "pull_request_review_requested",
+    "check_suite_completed",
+  ])("fetches the PR body html via issues.get for %s", async (trigger) => {
+    const { octokit, issuesGet } = makeOctokit();
+    const result = await resolveBody(ctxFor({ trigger, issue_number: 9, body: IMG_BODY }, octokit));
+    expect(issuesGet).toHaveBeenCalledWith(expect.objectContaining({ issue_number: 9 }));
+    expect(result).toBe("downloaded:issue html");
+  });
+
+  it("fetches the review html for pull_request_review_submitted", async () => {
+    const { octokit, pullsGetReview } = makeOctokit();
+    const result = await resolveBody(
+      ctxFor(
+        {
+          trigger: "pull_request_review_submitted",
+          issue_number: 9,
+          review_id: 21,
+          body: IMG_BODY,
+        },
+        octokit,
+      ),
+    );
+    expect(pullsGetReview).toHaveBeenCalledWith(
+      expect.objectContaining({ pull_number: 9, review_id: 21 }),
+    );
+    expect(result).toBe("downloaded:review html");
+  });
+
+  it("skips the fetch when pull_request_review_submitted lacks a review id", async () => {
+    const { octokit, pullsGetReview } = makeOctokit();
+    await resolveBody(
+      ctxFor(
+        { trigger: "pull_request_review_submitted", issue_number: 9, body: IMG_BODY },
+        octokit,
+      ),
+    );
+    expect(pullsGetReview).not.toHaveBeenCalled();
+  });
+
+  it("fetches the review comment html for pull_request_review_comment_created", async () => {
+    const { octokit, pullsGetReviewComment } = makeOctokit();
+    const result = await resolveBody(
+      ctxFor(
+        { trigger: "pull_request_review_comment_created", comment_id: 31, body: IMG_BODY },
+        octokit,
+      ),
+    );
+    expect(pullsGetReviewComment).toHaveBeenCalledWith(expect.objectContaining({ comment_id: 31 }));
+    expect(result).toBe("downloaded:review comment html");
+  });
+
+  it("fetches the plan comment html for implement_plan", async () => {
+    const { octokit, issuesGetComment } = makeOctokit();
+    const result = await resolveBody(
+      ctxFor({ trigger: "implement_plan", plan_comment_id: 41, body: IMG_BODY }, octokit),
+    );
+    expect(issuesGetComment).toHaveBeenCalledWith(expect.objectContaining({ comment_id: 41 }));
+    expect(result).toBe("downloaded:comment html");
+  });
+
+  it.each([
+    "workflow_dispatch",
+    "fix_review",
+    "unknown",
+  ])("never fetches html for bodyless trigger %s", async (trigger) => {
+    const { octokit, issuesGet, issuesGetComment } = makeOctokit();
+    const result = await resolveBody(ctxFor({ trigger, body: IMG_BODY }, octokit));
+    expect(issuesGet).not.toHaveBeenCalled();
+    expect(issuesGetComment).not.toHaveBeenCalled();
+    expect(result).toBe(`downloaded:${IMG_BODY}`);
+  });
+});

package/src/utils/body.ts

@@ -0,0 +1,168 @@
+import TurndownService from "turndown";
+import type { PayloadEvent } from "#app/external";
+import { downloadAssetsInMarkdown } from "#app/utils/assets";
+import type { OctokitWithPlugins } from "#app/utils/github";
+import type { RunContextData } from "#app/utils/runContextData";
+
+const turndown = new TurndownService();
+
+function hasImages(body: string | null | undefined): boolean {
+  if (!body) return false;
+  return body.includes("<img") || body.includes("![");
+}
+
+interface ResolveBodyContext {
+  event: PayloadEvent;
+  octokit: OctokitWithPlugins;
+  repo: RunContextData["repo"];
+  tmpdir: string;
+  githubToken: string;
+}
+
+/**
+ * resolves the body of an event by fetching body_html and converting to markdown.
+ * only fetches body_html if the body contains images (to avoid unnecessary API calls).
+ * this ensures agents receive markdown with working signed image URLs instead of
+ * broken user-attachments URLs.
+ */
+export async function resolveBody(ctx: ResolveBodyContext): Promise<string | null> {
+  const body = ctx.event.body;
+  const bodyHtml = hasImages(body) ? await fetchBodyHtml(ctx) : undefined;
+  return resolveBodyAssets({
+    body,
+    bodyHtml,
+    tmpdir: ctx.tmpdir,
+    githubToken: ctx.githubToken,
+  });
+}
+
+interface ResolveBodyAssetsContext {
+  body: string | null | undefined;
+  bodyHtml: string | null | undefined;
+  tmpdir: string;
+  githubToken: string;
+}
+
+/**
+ * downloads github-hosted image assets in a body to disk and rewrites the urls to local
+ * paths so the agent can read them. when the body has images and a rendered `bodyHtml`
+ * is supplied, the html is turndowned first: github only exposes attachments as signed,
+ * self-authenticating `*.githubusercontent.com` urls through body_html — the raw
+ * `github.com/user-attachments/...` urls in unrendered markdown 404 for the installation
+ * token. callers that fetch a body should request it with the `application/vnd.github.full+json`
+ * media type and pass `body_html` here.
+ */
+export async function resolveBodyAssets(ctx: ResolveBodyAssetsContext): Promise<string | null> {
+  let body = ctx.body ?? null;
+  if (body && hasImages(body) && ctx.bodyHtml) {
+    body = turndown.turndown(ctx.bodyHtml);
+  }
+  if (!body) return ctx.body ?? null;
+  return downloadAssetsInMarkdown(body, ctx.tmpdir, ctx.githubToken);
+}
+
+async function fetchBodyHtml(ctx: ResolveBodyContext): Promise<string | undefined> {
+  const event = ctx.event;
+  const headers = { accept: "application/vnd.github.full+json" };
+  const owner = ctx.repo.owner;
+  const repo = ctx.repo.name;
+
+  switch (event.trigger) {
+    case "issue_comment_created":
+      if (!event.comment_id) return;
+      return (
+        await ctx.octokit.rest.issues.getComment({
+          owner,
+          repo,
+          comment_id: event.comment_id,
+          headers,
+        })
+      ).data.body_html;
+
+    case "issues_opened":
+    case "issues_assigned":
+    case "issues_labeled":
+      if (!event.issue_number) return;
+      return (
+        await ctx.octokit.rest.issues.get({
+          owner,
+          repo,
+          issue_number: event.issue_number,
+          headers,
+        })
+      ).data.body_html;
+
+    case "pull_request_opened":
+    case "pull_request_ready_for_review":
+    case "pull_request_synchronize":
+    case "pull_request_review_requested":
+      // PRs are also issues - use issues.get which returns body_html
+      if (!event.issue_number) return;
+      return (
+        await ctx.octokit.rest.issues.get({
+          owner,
+          repo,
+          issue_number: event.issue_number,
+          headers,
+        })
+      ).data.body_html;
+
+    case "pull_request_review_submitted":
+      if (!event.issue_number || !event.review_id) return;
+      return (
+        await ctx.octokit.rest.pulls.getReview({
+          owner,
+          repo,
+          pull_number: event.issue_number,
+          review_id: event.review_id,
+          headers,
+        })
+      ).data.body_html;
+
+    case "pull_request_review_comment_created":
+      if (!event.comment_id) return;
+      return (
+        await ctx.octokit.rest.pulls.getReviewComment({
+          owner,
+          repo,
+          comment_id: event.comment_id,
+          headers,
+        })
+      ).data.body_html;
+
+    case "check_suite_completed":
+      // body is the PR body
+      if (!event.issue_number) return;
+      return (
+        await ctx.octokit.rest.issues.get({
+          owner,
+          repo,
+          issue_number: event.issue_number,
+          headers,
+        })
+      ).data.body_html;
+
+    case "implement_plan":
+      // body is the plan content from an issue comment
+      if (!event.plan_comment_id) return;
+      return (
+        await ctx.octokit.rest.issues.getComment({
+          owner,
+          repo,
+          comment_id: event.plan_comment_id,
+          headers,
+        })
+      ).data.body_html;
+
+    // triggers without a body field that needs resolution
+    case "workflow_dispatch":
+    case "fix_review":
+    case "unknown":
+      return undefined;
+
+    default:
+      // exhaustiveness check - TypeScript will error if a trigger is missing
+      event satisfies never;
+      return undefined;
+  }
+}

package/src/utils/buildTerramendFooter.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { buildTerramendFooter } from "#app/utils/buildTerramendFooter";
+
+describe("buildTerramendFooter — fallbackFrom annotation", () => {
+  it("renders the provider display name when fallbackFrom is set", () => {
+    const footer = buildTerramendFooter({
+      model: "opencode/big-pickle",
+      fallbackFrom: "anthropic/claude-opus",
+    });
+    expect(footer).toContain(
+      "Using `Big Pickle` (free) (credentials for Anthropic not configured)",
+    );
+  });
+
+  it("works for OpenAI's display name too", () => {
+    const footer = buildTerramendFooter({
+      model: "opencode/big-pickle",
+      fallbackFrom: "openai/gpt",
+    });
+    expect(footer).toContain("(credentials for OpenAI not configured)");
+  });
+
+  it("falls back to the raw provider key when the slug provider is unknown to the catalog", () => {
+    const footer = buildTerramendFooter({
+      model: "opencode/big-pickle",
+      fallbackFrom: "some-unknown/model",
+    });
+    expect(footer).toContain("(credentials for some-unknown not configured)");
+  });
+
+  it("omits the annotation when fallbackFrom is not set", () => {
+    const footer = buildTerramendFooter({
+      model: "anthropic/claude-opus",
+    });
+    expect(footer).toContain("Using `Claude Opus`");
+    expect(footer).not.toContain("not configured");
+  });
+});

package/src/utils/buildTerramendFooter.ts

@@ -0,0 +1,82 @@
+import { getModelProvider, modelAliases, providers, resolveDisplayAlias } from "#app/models";
+
+export const TERRAMEND_DIVIDER = "<!-- TERRAMEND_DIVIDER_DO_NOT_REMOVE_PLZ -->";
+
+export interface BuildTerramendFooterParams {
+  /** add "via Terramend" link */
+  triggeredBy?: boolean;
+  /** arbitrary custom parts (e.g., action links) */
+  customParts?: string[] | undefined;
+  /** model slug from payload (e.g., "anthropic/claude-opus"). shown in footer as "Using `Model Name`" */
+  model?: string | undefined;
+  /**
+   * When the action engaged the BYOK fallback, this is the slug the user
+   * had configured (e.g. "anthropic/claude-opus") — the footer renders
+   * `Using <free model> (credentials for <configured> not configured)`
+   * so the substitution is visible in PR comments + reviews.
+   */
+  fallbackFrom?: string | undefined;
+}
+
+/** Provider display name (e.g. "Anthropic") for the slug, or the raw provider segment as a fallback. */
+function providerDisplayName(slug: string): string {
+  try {
+    const key = getModelProvider(slug);
+    const meta = providers[key as keyof typeof providers];
+    return meta?.displayName ?? key;
+  } catch {
+    // raw IDs without a `/` (Bedrock model IDs) — never reach this function
+    // in practice because the BYOK fallback skips Bedrock, but defensively
+    // return the slug itself rather than throw if it ever does.
+    return slug;
+  }
+}
+
+function formatModelLabel(params: { model: string; fallbackFrom?: string | undefined }): string {
+  const alias =
+    resolveDisplayAlias(params.model) ??
+    // reverse-lookup: when the caller passes an effective model (proxy or
+    // resolved target like "openrouter/anthropic/claude-opus-4.7") instead of
+    // a stored alias slug, find the alias whose resolve target matches so we
+    // still render a friendly display name.
+    modelAliases.find((a) => a.resolve === params.model || a.openRouterResolve === params.model);
+  const displayName = alias?.displayName ?? params.model;
+  const base = alias?.isFree ? `\`${displayName}\` (free)` : `\`${displayName}\``;
+  if (!params.fallbackFrom) return base;
+  return `${base} (credentials for ${providerDisplayName(params.fallbackFrom)} not configured)`;
+}
+
+/**
+ * build a terramend footer with configurable parts
+ * order: action links (customParts) > model > attribution
+ */
+export function buildTerramendFooter(params: BuildTerramendFooterParams): string {
+  const parts: string[] = [];
+
+  if (params.customParts) {
+    parts.push(...params.customParts);
+  }
+
+  if (params.triggeredBy) {
+    parts.push("via Terramend");
+  }
+
+  if (params.model) {
+    parts.push(
+      `Using ${formatModelLabel({ model: params.model, fallbackFrom: params.fallbackFrom })}`,
+    );
+  }
+
+  return `\n\n${TERRAMEND_DIVIDER}\n<sup>${parts.join(" ｜ ")}</sup>`;
+}
+
+/**
+ * strip any existing terramend footer from a comment body
+ */
+export function stripExistingFooter(body: string): string {
+  const dividerIndex = body.indexOf(TERRAMEND_DIVIDER);
+  if (dividerIndex === -1) {
+    return body;
+  }
+  return body.substring(0, dividerIndex).trimEnd();
+}