pr-shepherd 0.9.0 → 0.10.0

package/bin/github/client.mjs

@@ -8,7 +8,7 @@
 import { execFile as execFileCb } from "node:child_process";
 import { promisify } from "node:util";
 import { graphql as httpGraphql, rest } from "./http.mjs";
-import { PR_NUMBER_BY_BRANCH_QUERY } from "./queries.mjs";
+import { PR_NUMBER_BY_BRANCH_QUERY, GET_PR_HEAD_SHA_QUERY } from "./queries.mjs";
 const execFile = promisify(execFileCb);
 // ---------------------------------------------------------------------------
 // GraphQL — thin re-exports so callers don't need to import http.mts directly
@@ -42,38 +42,17 @@ export async function getCurrentPrNumber() {
 }
 /** Returns the `headRefOid` (commit SHA) of the given PR as reported by GitHub. */
 export async function getPrHeadSha(pr, owner, name) {
-    const data = await rest("GET", `/repos/${owner}/${name}/pulls/${pr}`);
-    return data.head.sha;
-}
-/**
- * Full head info for a PR — sha, branch name, and the head repository's full name.
- * Needed by commit-suggestions to target the correct branch via `createCommitOnBranch`.
- */
-export async function getPrHead(pr, owner, name) {
-    const data = await rest("GET", `/repos/${owner}/${name}/pulls/${pr}`);
-    if (!data.head.repo) {
-        throw new Error(`PR #${pr} head repository is unavailable (fork may have been deleted).`);
-    }
-    return {
-        sha: data.head.sha,
-        ref: data.head.ref,
-        repoWithOwner: data.head.repo.full_name,
-    };
-}
-/**
- * Fetch a file's raw text content at a given ref. Uses the REST contents endpoint,
- * which returns base64 for files under 1MB. Throws for binary / oversize files.
- */
-export async function getFileContents(repoWithOwner, path, ref) {
-    const data = await rest("GET", `/repos/${repoWithOwner}/contents/${encodePathForApi(path)}?ref=${encodeURIComponent(ref)}`);
-    if (!data.content || data.encoding !== "base64") {
-        throw new Error(`File ${path} could not be read as text (encoding=${data.encoding ?? "n/a"}).`);
+    const result = await httpGraphql(GET_PR_HEAD_SHA_QUERY, { owner, repo: name, pr });
+    const sha = result.data.repository?.pullRequest?.headRefOid;
+    if (!sha) {
+        const detail = !result.data.repository
+            ? "repository not found or access denied"
+            : !result.data.repository.pullRequest
+                ? "PR not found or access denied"
+                : "headRefOid missing";
+        throw new Error(`Could not resolve head SHA for ${owner}/${name} PR #${pr}: ${detail}`);
     }
-    return Buffer.from(data.content, "base64").toString("utf8");
-}
-// Encode every path segment but preserve the slashes between them.
-function encodePathForApi(path) {
-    return path.split("/").map(encodeURIComponent).join("/");
+    return sha;
 }
 /**
  * Fetches `mergeable` and `mergeStateStatus` via the REST API.

package/bin/github/gql/batch-pr.gql

@@ -19,6 +19,10 @@ query BatchPr(
       mergeStateStatus
       reviewDecision
       headRefOid
+      headRefName
+      headRepository {
+        nameWithOwner
+      }
       baseRefName
       # Not paginated — capped at 50; PRs with more pending reviewers truncate silently.
       reviewRequests(last: 50) {

package/bin/github/gql/get-pr-head-sha.gql

@@ -0,0 +1,7 @@
+query GetPrHeadSha($owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      headRefOid
+    }
+  }
+}

package/bin/github/http.mjs

@@ -1,5 +1,7 @@
 import { execFile as execFileCb } from "node:child_process";
 import { promisify } from "node:util";
+import { appendEntry, nextEntry } from "../log/log-file.mjs";
+import { formatRequestEntry, formatResponseEntry } from "../log/session.mjs";
 const execFile = promisify(execFileCb);
 const BASE_URL = "https://api.github.com";
 // ---------------------------------------------------------------------------
@@ -42,33 +44,87 @@ async function makeHeaders() {
 function sanitizeBody(body) {
     return body.replace(/Bearer\s+\S+/gi, "[REDACTED]").slice(0, 200);
 }
-async function requestWithTokenRetry(fn) {
+function redactToken(body) {
+    return body.replace(/Bearer\s+\S+/gi, "[REDACTED]");
+}
+function redactUrl(url) {
+    try {
+        const u = new URL(url);
+        return `${u.origin}${u.pathname}`;
+    }
+    catch {
+        return url;
+    }
+}
+async function requestWithTokenRetry(fn, t0, onIntermediate) {
     const res = await fn();
     if (res.status === 401 && _token !== undefined) {
+        onIntermediate?.(401, Math.round(performance.now() - t0));
         try {
             await res.arrayBuffer();
         }
         catch { }
         _token = undefined;
-        return fn();
+        const retryT0 = performance.now();
+        return { res: await fn(), attempt: 2, retryT0 };
     }
-    return res;
+    return { res, attempt: 1, retryT0: t0 };
 }
 // ---------------------------------------------------------------------------
 // GraphQL
 // ---------------------------------------------------------------------------
 async function graphqlInner(query, vars) {
-    const res = await requestWithTokenRetry(async () => fetch(`${BASE_URL}/graphql`, {
+    const url = `${BASE_URL}/graphql`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({
+        n,
+        kind: "GraphQL",
+        method: "POST",
+        url,
+        body: { query, variables: vars },
+    }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
         method: "POST",
         headers: await makeHeaders(),
         body: JSON.stringify({ query, variables: vars }),
-    }));
+    }), t0, (status, firstDurationMs) => {
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "GraphQL",
+            method: "POST",
+            url,
+            status,
+            durationMs: firstDurationMs,
+        }));
+    });
+    const durationMs = Math.round(performance.now() - retryT0);
     const rateLimit = parseRateLimit(res.headers);
     if (!res.ok) {
         const body = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "GraphQL",
+            method: "POST",
+            url,
+            status: res.status,
+            durationMs,
+            textBody: redactToken(body),
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
         throw new Error(`GitHub GraphQL request failed: ${res.status} ${sanitizeBody(body)}`);
     }
     const parsed = (await res.json());
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "GraphQL",
+        method: "POST",
+        url,
+        status: res.status,
+        durationMs,
+        body: parsed,
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
     if (parsed.data == null) {
         const messages = (parsed.errors ?? []).map((e) => e.message).join("; ");
         throw new Error(`GitHub GraphQL error (no data): ${messages}`);
@@ -91,31 +147,109 @@ export async function graphqlWithRateLimit(query, vars = {}) {
 // REST
 // ---------------------------------------------------------------------------
 export async function rest(method, path, body) {
-    const res = await requestWithTokenRetry(async () => fetch(`${BASE_URL}${path}`, {
+    const url = `${BASE_URL}${path}`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({ n, kind: "REST", method, url, body }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
         method,
         headers: await makeHeaders(),
         body: body !== undefined ? JSON.stringify(body) : undefined,
-    }));
+    }), t0, (status, firstDurationMs) => {
+        appendEntry(formatResponseEntry({ n, kind: "REST", method, url, status, durationMs: firstDurationMs }));
+    });
+    const durationMs = Math.round(performance.now() - retryT0);
+    const ct = res.headers.get("content-type") ?? "";
     if (!res.ok) {
         const text = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "REST",
+            method,
+            url,
+            status: res.status,
+            durationMs,
+            textBody: redactToken(text),
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
         throw new Error(`GitHub REST ${method} ${path} failed: ${res.status} ${sanitizeBody(text)}`);
     }
-    const ct = res.headers.get("content-type") ?? "";
     if (ct.includes("application/json")) {
-        return res.json();
+        const json = (await res.json());
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "REST",
+            method,
+            url,
+            status: res.status,
+            durationMs,
+            contentType: ct,
+            body: json,
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
+        return json;
     }
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "REST",
+        method,
+        url,
+        status: res.status,
+        durationMs,
+        contentType: ct || undefined,
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
     return undefined;
 }
 export async function restText(path) {
-    const res = await requestWithTokenRetry(async () => fetch(`${BASE_URL}${path}`, {
+    const url = `${BASE_URL}${path}`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({ n, kind: "restText", method: "GET", url }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
         method: "GET",
         headers: await makeHeaders(),
         redirect: "manual",
-    }));
+    }), t0, (status, firstDurationMs) => {
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "restText",
+            method: "GET",
+            url,
+            status,
+            durationMs: firstDurationMs,
+        }));
+    });
+    const durationMs = Math.round(performance.now() - retryT0);
     if (res.status === 301 || res.status === 302 || res.status === 307 || res.status === 308) {
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "restText",
+            method: "GET",
+            url,
+            status: res.status,
+            durationMs,
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
         const location = res.headers.get("location");
         if (location) {
+            const n2 = nextEntry();
+            const logUrl = redactUrl(location);
+            appendEntry(formatRequestEntry({ n: n2, kind: "restText", method: "GET", url: logUrl }));
+            const t1 = performance.now();
             const redirectRes = await fetch(location);
+            const duration2 = Math.round(performance.now() - t1);
+            const clRaw = redirectRes.headers.get("content-length");
+            const contentLength = clRaw !== null && Number.isFinite(Number(clRaw)) ? Number(clRaw) : undefined;
+            appendEntry(formatResponseEntry({
+                n: n2,
+                kind: "restText",
+                method: "GET",
+                url: logUrl,
+                status: redirectRes.status,
+                durationMs: duration2,
+                contentLength,
+            }));
             if (!redirectRes.ok) {
                 throw new Error(`redirect target ${location} failed: ${redirectRes.status}`);
             }
@@ -124,8 +258,29 @@ export async function restText(path) {
     }
     if (!res.ok) {
         const text = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "restText",
+            method: "GET",
+            url,
+            status: res.status,
+            durationMs,
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
         throw new Error(`GitHub REST GET ${path} failed: ${res.status} ${sanitizeBody(text)}`);
     }
+    const clRaw = res.headers.get("content-length");
+    const contentLength = clRaw !== null && Number.isFinite(Number(clRaw)) ? Number(clRaw) : undefined;
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "restText",
+        method: "GET",
+        url,
+        status: res.status,
+        durationMs,
+        contentLength,
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
     return res.text();
 }
 // ---------------------------------------------------------------------------

package/bin/github/queries.mjs

@@ -1,23 +1,19 @@
 /**
  * GraphQL query strings used by pr-shepherd.
  *
- * Query strings live in src/github/gql/*.gql.
- * Never inline raw GraphQL strings in .ts source files.
+ * Static query strings live in src/github/gql/*.gql and are loaded here.
+ * Dynamic documents whose content varies per call (e.g. BulkApply in
+ * src/comments/resolve.mts) are built at runtime and are exempt — they
+ * cannot be expressed as static files.
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 const gql = (name) => readFileSync(join(import.meta.dirname, "gql", name), "utf8");
 /** The primary batch query that fetches CI + comments + merge status in one round-trip. */
 export const BATCH_PR_QUERY = gql("batch-pr.gql");
-/** Resolve a single review thread. */
-export const RESOLVE_THREAD_MUTATION = gql("resolve-thread.gql");
-/** Minimize a PR comment (IssueComment). */
-export const MINIMIZE_COMMENT_MUTATION = gql("minimize-comment.gql");
-/** Dismiss a pull request review. */
-export const DISMISS_REVIEW_MUTATION = gql("dismiss-review.gql");
-/** Multi-PR status query for `shepherd status PR1 PR2 …`. */
-export const MULTI_PR_STATUS_QUERY = gql("multi-pr-status.gql");
-/** Paginated version — used when reviewThreads is truncated (totalCount > 100). */
+/** Returns the current head commit SHA for a PR. Used by waitForSha polling. */
+export const GET_PR_HEAD_SHA_QUERY = gql("get-pr-head-sha.gql");
+/** Paginated follow-up for `shepherd status` — used when reviewThreads is truncated (totalCount > 100). */
 export const MULTI_PR_STATUS_QUERY_WITH_CURSOR = gql("multi-pr-status-paged.gql");
 /** Look up PR number by branch name (for getCurrentPrNumber). */
 export const PR_NUMBER_BY_BRANCH_QUERY = gql("pr-number-by-branch.gql");

package/bin/log/log-file.mjs

@@ -0,0 +1,88 @@
+/**
+ * Append-only per-worktree markdown log.
+ *
+ * Log path: $PR_SHEPHERD_STATE_DIR/<owner>-<repo>/worktrees/<basename>-<sha8>.md
+ *
+ * Always-on by default. Set PR_SHEPHERD_LOG_DISABLED=1 or CI=true to disable.
+ * Write failures flip an internal disabled flag so the CLI never crashes because
+ * logging failed.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveStateBase } from "../state/base.mjs";
+import { SAFE_SEGMENT } from "../util/path-segment.mjs";
+import { getWorktreeKey } from "../util/worktree.mjs";
+function computeDisabled() {
+    if (process.env["PR_SHEPHERD_LOG_DISABLED"] === "1")
+        return true;
+    const ci = process.env["CI"];
+    return ci !== undefined && ci !== "" && ci !== "0" && ci !== "false";
+}
+let _disabled = computeDisabled();
+let _logPath = null;
+let _entryCounter = 0;
+/** Returns the next monotonically-increasing entry number for the current session. */
+export function nextEntry() {
+    return ++_entryCounter;
+}
+export function getLogFilePath(key) {
+    const { owner, repo } = key;
+    if (!SAFE_SEGMENT.test(owner) || !SAFE_SEGMENT.test(repo)) {
+        throw new Error(`Invalid repo key segments: ${owner}/${repo}`);
+    }
+    const base = resolveStateBase();
+    // Worktree key injected at init time; fall back to "unknown" if not yet set.
+    const wkey = _worktreeKey ?? "unknown";
+    return join(base, `${owner}-${repo}`, "worktrees", `${wkey}.md`);
+}
+let _worktreeKey = null;
+/**
+ * Initialize the log for this process. Must be called before appendEntry().
+ * Silently disables logging on any error (no git repo, bad repo name, etc.).
+ */
+export async function initLog(repoKey) {
+    if (_disabled)
+        return null;
+    try {
+        const { owner, repo } = repoKey;
+        if (!SAFE_SEGMENT.test(owner) || !SAFE_SEGMENT.test(repo))
+            return null;
+        _worktreeKey = await getWorktreeKey();
+        const path = getLogFilePath(repoKey);
+        mkdirSync(dirname(path), { recursive: true });
+        _logPath = path;
+        return path;
+    }
+    catch {
+        _disabled = true;
+        return null;
+    }
+}
+/** Append a pre-formatted markdown chunk to the log. No-op if disabled. */
+export function appendEntry(markdown) {
+    if (_disabled || _logPath === null)
+        return;
+    try {
+        appendFileSync(_logPath, markdown);
+    }
+    catch (e) {
+        process.stderr.write(`pr-shepherd: log write failed (disabling log): ${String(e)}\n`);
+        _disabled = true;
+    }
+}
+/** Resolve the log path without initializing (for the log-file subcommand). */
+export async function resolveLogPath(repoKey) {
+    if (!SAFE_SEGMENT.test(repoKey.owner) || !SAFE_SEGMENT.test(repoKey.repo)) {
+        throw new Error(`Invalid repo key segments: ${repoKey.owner}/${repoKey.repo}`);
+    }
+    const wkey = await getWorktreeKey();
+    const base = resolveStateBase();
+    return join(base, `${repoKey.owner}-${repoKey.repo}`, "worktrees", `${wkey}.md`);
+}
+/** Exposed for tests to reset module state. */
+export function _resetLogState() {
+    _disabled = computeDisabled();
+    _logPath = null;
+    _worktreeKey = null;
+    _entryCounter = 0;
+}

package/bin/log/session.mjs

@@ -0,0 +1,100 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+function readVersion() {
+    const pkgUrl = new URL("../../package.json", import.meta.url);
+    const pkg = JSON.parse(readFileSync(fileURLToPath(pkgUrl), "utf8"));
+    return pkg.version;
+}
+/** Builds the session header markdown block. */
+export function buildSessionHeader(argv) {
+    const ts = new Date().toISOString();
+    const cmd = argv.slice(2).join(" ") || "(no args)";
+    const markdown = `## ${ts} — pr-shepherd ${cmd}\n\n` + `pid: ${process.pid} · version: ${readVersion()}\n\n`;
+    return { markdown };
+}
+const _maxBodyRaw = Number(process.env["PR_SHEPHERD_LOG_MAX_BODY"]);
+const MAX_BODY = Number.isFinite(_maxBodyRaw) && _maxBodyRaw > 0 ? _maxBodyRaw : 256 * 1024;
+function truncate(s) {
+    if (s.length <= MAX_BODY)
+        return s;
+    return `${s.slice(0, MAX_BODY)}\n...[truncated ${s.length - MAX_BODY} characters]`;
+}
+function fenceBody(body, lang) {
+    const raw = typeof body === "string" ? body : JSON.stringify(body);
+    return `\`\`\`${lang}\n${truncate(raw)}\n\`\`\`\n`;
+}
+function extractOperationName(query) {
+    const match = /^\s*(?:query|mutation|subscription)\s+(\w+)/m.exec(query);
+    return match?.[1] ?? "(anonymous)";
+}
+export function formatRequestEntry(entry) {
+    const ts = new Date().toISOString();
+    const label = entry.kind === "GraphQL"
+        ? `GraphQL request — POST ${entry.url}`
+        : entry.kind === "restText"
+            ? `restText request — GET ${entry.url}`
+            : `REST request — ${entry.method} ${entry.url}`;
+    let out = `### #${entry.n} ${label} · ${ts}\n\n`;
+    if (entry.kind === "restText") {
+        out += `(body omitted: log artifact)\n\n`;
+        return out;
+    }
+    if (entry.body !== undefined && entry.kind === "GraphQL") {
+        const { query, variables } = entry.body;
+        out += `operation: \`${extractOperationName(query)}\`\n`;
+        if (variables && Object.keys(variables).length > 0) {
+            out += `variables:\n${fenceBody(variables, "json")}`;
+        }
+        else {
+            // For dynamic documents (e.g. BulkApply) the IDs are inlined as aliases.
+            // Count the aliases so the log shows how many operations were batched.
+            const aliasCount = (query.match(/^\s+[_A-Za-z]\w*:/gm) ?? []).length;
+            if (aliasCount > 0)
+                out += `aliases: ${aliasCount}\n`;
+        }
+    }
+    else if (entry.body !== undefined) {
+        out += fenceBody(entry.body, "json");
+    }
+    else {
+        out += `(no body)\n`;
+    }
+    return out + "\n";
+}
+export function formatResponseEntry(entry) {
+    const ts = new Date().toISOString();
+    const attempt = entry.attempt !== undefined ? ` (attempt ${entry.attempt}/2 after 401)` : "";
+    const label = entry.kind === "GraphQL"
+        ? `GraphQL response — ${entry.status}${attempt} · ${entry.durationMs}ms`
+        : entry.kind === "restText"
+            ? `restText response — ${entry.status}${attempt} · ${entry.durationMs}ms`
+            : `REST response — ${entry.status}${attempt} · ${entry.durationMs}ms`;
+    let out = `### #${entry.n} ${label} · ${ts}\n\n`;
+    if (entry.kind === "restText") {
+        if (entry.contentLength !== undefined) {
+            out += `content-length: ${entry.contentLength} bytes (body not logged)\n\n`;
+        }
+        else {
+            out += `(body not logged)\n\n`;
+        }
+        return out;
+    }
+    if (entry.contentType !== undefined) {
+        out += `content-type: ${entry.contentType}`;
+        if (entry.contentLength !== undefined)
+            out += ` · ${entry.contentLength} bytes`;
+        out += "\n";
+    }
+    if (entry.body !== undefined) {
+        out += fenceBody(entry.body, "json");
+    }
+    else if (entry.textBody !== undefined) {
+        out += fenceBody(entry.textBody, "");
+    }
+    return out + "\n";
+}
+export function formatOutputEntry(text, format) {
+    const ts = new Date().toISOString();
+    const lang = format === "json" ? "json" : "";
+    return `### Output (${format}) · ${ts}\n\n${fenceBody(text.trimEnd(), lang)}\n`;
+}

package/bin/log/setup.mjs

@@ -0,0 +1,54 @@
+import { initLog, appendEntry } from "./log-file.mjs";
+import { buildSessionHeader, formatOutputEntry } from "./session.mjs";
+import { getRepoInfo } from "../github/client.mjs";
+let _done = false;
+function detectFormat(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--format=json")
+            return "json";
+        if (argv[i] === "--format" && argv[i + 1] === "json")
+            return "json";
+    }
+    return "text";
+}
+/**
+ * Initialize the per-worktree log, write the session header, and install a
+ * stdout tee that routes all CLI output to the log. No-op after the first call.
+ * Silently skips logging when not in a git repo or on any other error.
+ */
+export async function setupLog(argv) {
+    if (_done)
+        return;
+    _done = true;
+    try {
+        const { owner, name } = await getRepoInfo();
+        const log = await initLog({ owner, repo: name });
+        if (!log)
+            return;
+    }
+    catch {
+        return;
+    }
+    try {
+        const { markdown: header } = buildSessionHeader(argv);
+        appendEntry(header);
+        const format = detectFormat(argv);
+        const origWrite = process.stdout.write.bind(process.stdout);
+        process.stdout.write = (chunk, encodingOrCb, cb) => {
+            try {
+                const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+                if (text.length > 0)
+                    appendEntry(formatOutputEntry(text, format));
+            }
+            catch {
+                // Best-effort: logging must never interfere with CLI output.
+            }
+            return typeof encodingOrCb === "function"
+                ? origWrite(chunk, encodingOrCb)
+                : origWrite(chunk, encodingOrCb, cb);
+        };
+    }
+    catch {
+        // Best-effort: logging setup must never prevent the CLI from running.
+    }
+}

package/bin/reporters/agent.mjs

@@ -7,8 +7,21 @@
  * detailsUrl is preserved in AgentCheck as a fallback for external status checks.
  * The original domain types are preserved for check command output.
  */
+import { extractSuggestion } from "../suggestions/extract.mjs";
 export function toAgentThread(t) {
-    return { id: t.id, path: t.path, line: t.line, author: t.author, body: t.body, url: t.url };
+    const suggestion = extractSuggestion(t) ?? undefined;
+    return {
+        id: t.id,
+        path: t.path,
+        line: t.line,
+        ...(t.line !== null &&
+            t.startLine !== null &&
+            t.startLine !== t.line && { startLine: t.startLine }),
+        author: t.author,
+        body: t.body,
+        url: t.url,
+        ...(suggestion !== undefined && { suggestion }),
+    };
 }
 export function toAgentComment(c) {
     return { id: c.id, author: c.author, body: c.body, url: c.url };