@cursor/july 0.1.101 → 0.1.103

package/src/internal/review-comments.ts

@@ -1,1363 +0,0 @@
-import { spawn } from "node:child_process";
-import type { HostGitHubClient } from "../types.js";
-import { parsePrUrl } from "./scm/pr-url.js";
-
-export type ReviewCommentPublisher = "local_gh" | "host_github" | "host_origin";
-
-export type ReviewCommentPostResult = {
-  posted: boolean;
-  publisher: ReviewCommentPublisher;
-  mode: "review_with_inline_comments" | "review_body_only" | "skipped";
-  inlineCommentCount: number;
-  detail: string;
-  /**
-   * Ids of the inline comments this post created, when the publisher could
-   * read them back. Callers that later re-read a PR's comments use these as
-   * the provenance allowlist: a comment id we did not create is not ours,
-   * no matter what its body looks like. Empty when the publisher cannot
-   * resolve them (it never guesses).
-   */
-  postedComments?: PostedReviewComment[];
-};
-
-/** One inline comment this agent created, as the SCM assigned it. */
-export type PostedReviewComment = {
-  id: number;
-  file: string;
-  line: number;
-};
-
-export type ReviewInlineComment = {
-  file: string;
-  line: number;
-  start_line?: number;
-  body: string;
-};
-
-export type ReviewCommentPostArgs = {
-  prUrl: string;
-  reviewedHeadSha: string;
-  message: string;
-  comments: ReviewInlineComment[];
-  cleanupPrevious?: boolean;
-  signal?: AbortSignal;
-};
-
-export type ReviewCommentsRequest = {
-  provider: "github";
-  repo: string;
-  prNumber: number;
-  headSha: string;
-  message: string;
-  comments: ReviewInlineComment[];
-  cleanupPrevious: boolean;
-};
-
-export type ReviewCommentPublisherImplementation = {
-  postReview: (args: ReviewCommentPostArgs) => Promise<ReviewCommentPostResult>;
-};
-
-/**
- * SCMs this module can address. Same growth seam as `shallow-clone.ts`'s
- * {@link import("./shallow-clone.js").ScmProvider}: adding a forge means a
- * resolver case plus a publisher (and, when the public API supports it, a
- * reader / thread resolver). Callers above this line stay provider-neutral.
- */
-export type ScmReviewProvider = "github" | "origin";
-
-/**
- * Origin public REST client used to post PR reviews (`ctx.origin` /
- * {@link import("../channels/origin/api.js").createOriginClient}). Narrower
- * than the full Origin handle so tests and CLI paths can inject `request()`.
- */
-export type HostOriginReviewClient = {
-  request(input: {
-    method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
-    path: string;
-    body?: unknown;
-  }): Promise<unknown>;
-};
-
-/** Which SCM's PR to read review comments from. */
-export type ScmReviewTarget = {
-  provider: ScmReviewProvider;
-  /** `owner/name`. */
-  repo: string;
-  prNumber: number;
-};
-
-/** Optional structured logger for the read/resolve seams (`[asr]`-style). */
-export type ReviewCommentLog = (message: string) => void;
-
-/**
- * One inline review-thread comment from a PR-wide listing, provider-neutral.
- *
- * This is the Bugbot listing shape (`minimizePreviousBugBotComments` /
- * `getBugBotComments` normalize each provider's `getPRComments` output the
- * same way): a re-review lists everything on the PR and filters on its own
- * marker, rather than fetching ids it recorded elsewhere.
- */
-export type ListedReviewComment = {
-  /**
-   * Provider-native comment id, stringified for provider neutrality
-   * (GitHub REST database id in decimal; Origin `cmt_…`).
-   */
-  commentId: string;
-  /** GitHub REST numeric comment id, when the provider exposes one. */
-  numericCommentId?: number;
-  /**
-   * Id of the thread this comment opens, in the form the provider's thread
-   * resolver accepts (GitHub GraphQL thread node id; Origin `cth_…`).
-   */
-  threadId: string;
-  /** Whether the owning thread is already resolved. */
-  resolved: boolean;
-  file: string;
-  startLine: number;
-  endLine: number;
-  body: string;
-  /**
-   * Head SHA the comment was filed against (GitHub `originalCommit`; Origin
-   * the thread version's head SHA), when the provider exposes it. This is
-   * the commit a follow-up judge diffs forward from.
-   */
-  commitSha?: string;
-  authorLogin?: string;
-  /**
-   * Whether the SCM attributes the comment to a machine identity — a
-   * GitHub App bot (GraphQL author `__typename: "Bot"`) or an Origin
-   * app/service-account actor. Human accounts are `false`; `undefined`
-   * when the provider did not return an author (e.g. deleted account).
-   * Callers deciding whether a comment is their own must require `true`
-   * AND pin the specific identity (login / app id): body content is
-   * forgeable by any PR participant, and other bots/apps also comment.
-   */
-  authorIsBot?: boolean;
-  /**
-   * Origin app actor id (`app_…`) when the comment was authored by an app
-   * installation. Callers compare it against their own configured app id
-   * to decide the comment is theirs, not merely some app's.
-   */
-  authorAppId?: string;
-};
-
-export type ListReviewCommentsArgs = {
-  target: ScmReviewTarget;
-  signal?: AbortSignal;
-};
-
-/**
- * Read side of the review-comment seam, mirroring
- * {@link ReviewCommentPublisherImplementation}. Bugbot's equivalent is
- * `IGitProvider.getPRComments`: list the PR's inline review threads (their
- * opening comments) so a re-review can find its own previous comments.
- */
-export type ReviewCommentListerImplementation = {
-  listReviewComments: (
-    args: ListReviewCommentsArgs
-  ) => Promise<ListedReviewComment[]>;
-};
-
-export type ResolveReviewThreadsArgs = {
-  target: ScmReviewTarget;
-  /** Provider-native thread ids (from {@link ListedReviewComment.threadId}). */
-  threadIds: readonly string[];
-  signal?: AbortSignal;
-};
-
-/**
- * Outcome of resolving a set of review threads. Callers treat this as
- * best-effort actuation: a failed resolve must not fail the review that
- * already posted.
- */
-export type ResolveReviewThreadsResult = {
-  requested: number;
-  resolved: number;
-  failed: number;
-  detail: string;
-};
-
-/**
- * Write side of thread resolution, the counterpart of
- * {@link ReviewCommentListerImplementation}. Bugbot's equivalent is
- * `IGitProvider.resolveReviewThreadForComment` / `resolveThreads`.
- *
- * GitHub only exposes resolve via GraphQL (`resolveReviewThread`). REST
- * has no equivalent. The mutation runs as whatever identity minted the
- * bound GitHub client — for `githubChannel({ cursorAccount })` that is
- * the Cursor installation, the same identity that posted the comments.
- * Origin exposes resolve on the public REST API
- * (`PATCH …/pulls/threads/{thread_id}`).
- */
-export type ReviewThreadResolverImplementation = {
-  resolveReviewThreads: (
-    args: ResolveReviewThreadsArgs
-  ) => Promise<ResolveReviewThreadsResult>;
-};
-
-/** Parse a PR URL into the SCM target to read or post comments on. */
-export function resolveScmReviewTarget(
-  prUrl: string
-): ScmReviewTarget | undefined {
-  const parsed = parsePrUrl(prUrl);
-  if (parsed === undefined) {
-    return undefined;
-  }
-  return {
-    provider: parsed.provider,
-    repo: `${parsed.owner}/${parsed.repo}`,
-    prNumber: parsed.number,
-  };
-}
-
-/**
- * Lister for a resolved target, mirroring Bugbot's `createPrGitProvider`
- * dispatch. Returns undefined when the host cannot serve that provider (no
- * GitHub/Origin client bound), so callers degrade instead of throwing.
- */
-export function createReviewCommentLister(args: {
-  target: ScmReviewTarget;
-  github?: HostGitHubClient;
-  origin?: HostOriginReviewClient;
-  log?: ReviewCommentLog;
-}): ReviewCommentListerImplementation | undefined {
-  switch (args.target.provider) {
-    case "github":
-      return args.github === undefined
-        ? undefined
-        : createHostGithubReviewCommentLister(args.github, args.log);
-    case "origin":
-      return args.origin === undefined
-        ? undefined
-        : createHostOriginReviewCommentLister(args.origin, args.log);
-  }
-}
-
-/**
- * Resolver for a resolved target. Returns undefined when the host cannot
- * serve that provider, so callers degrade instead of throwing.
- */
-export function createReviewThreadResolver(args: {
-  target: ScmReviewTarget;
-  github?: HostGitHubClient;
-  origin?: HostOriginReviewClient;
-  log?: ReviewCommentLog;
-}): ReviewThreadResolverImplementation | undefined {
-  switch (args.target.provider) {
-    case "github":
-      return args.github === undefined
-        ? undefined
-        : createHostGithubReviewThreadResolver(args.github, args.log);
-    case "origin":
-      return args.origin === undefined
-        ? undefined
-        : createHostOriginReviewThreadResolver(args.origin, args.log);
-  }
-}
-
-/**
- * Resolve `threadIds` on `prUrl`'s PR.
- *
- * No-ops (never throws) when the PR is on an SCM this host cannot write,
- * no client is bound, or `threadIds` is empty. Same degrade-don't-fail
- * posture as {@link createReviewCommentLister}.
- */
-export async function resolveReviewThreads(args: {
-  prUrl: string;
-  threadIds: readonly string[];
-  github?: HostGitHubClient;
-  origin?: HostOriginReviewClient;
-  resolver?: ReviewThreadResolverImplementation;
-  signal?: AbortSignal;
-  log?: ReviewCommentLog;
-}): Promise<ResolveReviewThreadsResult> {
-  if (args.threadIds.length === 0) {
-    return skippedResolve("no threads to resolve");
-  }
-  const target = resolveScmReviewTarget(args.prUrl);
-  if (target === undefined) {
-    return skippedResolve("no SCM resolver for this PR URL");
-  }
-  const resolver =
-    args.resolver ??
-    createReviewThreadResolver({
-      target,
-      github: args.github,
-      origin: args.origin,
-      log: args.log,
-    });
-  if (resolver === undefined) {
-    return skippedResolve(
-      `no ${target.provider} client bound to resolve threads`
-    );
-  }
-  return resolver.resolveReviewThreads({
-    target,
-    threadIds: args.threadIds,
-    signal: args.signal,
-  });
-}
-
-/** Cap on pages pulled per PR; GitHub serves 100 comments per page. */
-const REVIEW_COMMENTS_MAX_PAGES = 5;
-const REVIEW_COMMENTS_PAGE_SIZE = 100;
-/** Cap on review-thread pages when listing a PR's inline threads. */
-const REVIEW_THREADS_MAX_PAGES = 20;
-const REVIEW_THREADS_PAGE_SIZE = 100;
-/** Cap on Origin comment pages pulled per PR (100 comments per page). */
-const ORIGIN_COMMENTS_MAX_PAGES = 20;
-const ORIGIN_COMMENTS_PAGE_SIZE = 100;
-
-type GithubThreadCommentNode = {
-  databaseId?: number | null;
-  body?: string | null;
-  author?: { login?: string | null; __typename?: string | null } | null;
-  originalCommit?: { oid?: string | null } | null;
-};
-
-type GithubReviewThreadNode = {
-  id?: string;
-  isResolved?: boolean;
-  path?: string | null;
-  line?: number | null;
-  originalLine?: number | null;
-  startLine?: number | null;
-  originalStartLine?: number | null;
-  comments?: {
-    nodes?: Array<GithubThreadCommentNode | null>;
-  };
-};
-
-type GithubReviewThreadsQuery = {
-  repository?: {
-    pullRequest?: {
-      reviewThreads?: {
-        nodes?: Array<GithubReviewThreadNode | null>;
-        pageInfo?: { hasNextPage?: boolean; endCursor?: string | null };
-      };
-    } | null;
-  } | null;
-};
-
-type GithubResolveThreadMutation = {
-  resolveReviewThread?: {
-    thread?: { isResolved?: boolean };
-  };
-};
-
-/**
- * Repo-scope header for GraphQL calls through the Cursor github-proxy.
- *
- * The proxy authorizes each call from `x-cursor-github-repos`, which the
- * channel Octokit derives from REST URLs (`/repos/{owner}/{repo}/…`).
- * GraphQL posts to `/graphql` — no repo in the URL — so without this
- * explicit header every GraphQL call is rejected in proxy mode. Harmless
- * against api.github.com, which ignores unknown headers.
- */
-function githubGraphqlScopeHeaders(repo: string): Record<string, string> {
-  return { "x-cursor-github-repos": repo.toLowerCase() };
-}
-
-/**
- * GitHub review thread → {@link ListedReviewComment} (its opening comment).
- *
- * Prefers the `original*` line fields — the position as of the review the
- * thread belongs to. `line` drifts as the PR gains commits, so a caller
- * correlating a comment with the review that produced it needs the original
- * position, the same fields Bugbot carries on `PullRequestCommentOutput`.
- */
-export function listedCommentFromGithubThread(
-  thread: GithubReviewThreadNode
-): ListedReviewComment | undefined {
-  const opener = thread.comments?.nodes?.[0];
-  if (
-    thread.id === undefined ||
-    thread.id === "" ||
-    opener === null ||
-    opener === undefined ||
-    opener.databaseId === undefined ||
-    opener.databaseId === null ||
-    typeof opener.body !== "string" ||
-    typeof thread.path !== "string" ||
-    thread.path === ""
-  ) {
-    return undefined;
-  }
-  // Take both lines from the same position set. Mixing them (original end
-  // line with the drifted current start line) would describe a range that
-  // never existed in either revision.
-  const original = thread.originalLine ?? undefined;
-  const endLine = original ?? thread.line ?? undefined;
-  if (endLine === undefined) {
-    return undefined;
-  }
-  const startLine =
-    (original === undefined ? thread.startLine : thread.originalStartLine) ??
-    endLine;
-  const commitSha = opener.originalCommit?.oid ?? undefined;
-  const authorLogin = opener.author?.login ?? undefined;
-  const authorType = opener.author?.__typename ?? undefined;
-  return {
-    commentId: String(opener.databaseId),
-    numericCommentId: opener.databaseId,
-    threadId: thread.id,
-    resolved: thread.isResolved === true,
-    file: thread.path,
-    startLine,
-    endLine,
-    body: opener.body,
-    ...(commitSha === undefined ? {} : { commitSha }),
-    ...(authorLogin === undefined ? {} : { authorLogin }),
-    ...(authorType === undefined ? {} : { authorIsBot: authorType === "Bot" }),
-  };
-}
-
-/**
- * Lists the PR's inline review threads (their opening comments) through the
- * host GitHub client (Cursor account lease, App installation token, or
- * PAT). One paged GraphQL query yields, per thread: the resolvable thread
- * node id, its resolution state, the opener's body/position, and the commit
- * it was filed against — everything a Bugbot-style re-review needs.
- */
-export function createHostGithubReviewCommentLister(
-  github: HostGitHubClient,
-  log?: ReviewCommentLog
-): ReviewCommentListerImplementation {
-  return {
-    async listReviewComments({ target, signal }) {
-      const [owner, repo] = target.repo.split("/", 2);
-      if (owner === undefined || repo === undefined || repo === "") {
-        log?.(`github list: unparseable owner/repo "${target.repo}"`);
-        return [];
-      }
-      const octokit = await github.getOctokit();
-      const comments: ListedReviewComment[] = [];
-      let threadCount = 0;
-      let cursor: string | null = null;
-      for (let page = 0; page < REVIEW_THREADS_MAX_PAGES; page++) {
-        signal?.throwIfAborted();
-        const response = (await octokit.graphql(
-          REVIEW_THREAD_COMMENTS_FOR_PR_QUERY,
-          {
-            owner,
-            repo,
-            number: target.prNumber,
-            cursor,
-            headers: githubGraphqlScopeHeaders(target.repo),
-          }
-        )) as GithubReviewThreadsQuery;
-        const reviewThreads = response.repository?.pullRequest?.reviewThreads;
-        for (const thread of reviewThreads?.nodes ?? []) {
-          if (thread === null || thread === undefined) {
-            continue;
-          }
-          threadCount += 1;
-          const listed = listedCommentFromGithubThread(thread);
-          if (listed !== undefined) {
-            comments.push(listed);
-          }
-        }
-        const pageInfo = reviewThreads?.pageInfo;
-        if (pageInfo?.hasNextPage !== true || !pageInfo.endCursor) {
-          break;
-        }
-        cursor = pageInfo.endCursor;
-      }
-      log?.(
-        `github list: ${target.repo}#${target.prNumber} has ${threadCount} review thread(s), ${comments.length} with a normalizable opening comment`
-      );
-      return comments;
-    },
-  };
-}
-
-/**
- * Resolves inline review threads by GraphQL thread node id through the host
- * GitHub client (Cursor account lease, App installation token, or PAT) —
- * the id the lister already returned, so no comment→thread mapping pass is
- * needed. Same mutation as Bugbot's `resolveReviewThreadForComment`.
- */
-export function createHostGithubReviewThreadResolver(
-  github: HostGitHubClient,
-  log?: ReviewCommentLog
-): ReviewThreadResolverImplementation {
-  return {
-    async resolveReviewThreads({ target, threadIds, signal }) {
-      const uniqueIds = [...new Set(threadIds.filter((id) => id !== ""))];
-      if (uniqueIds.length === 0) {
-        return skippedResolve("no threads to resolve");
-      }
-      let resolved = 0;
-      let failed = 0;
-      try {
-        const octokit = await github.getOctokit();
-        for (const threadId of uniqueIds) {
-          signal?.throwIfAborted();
-          try {
-            const mutation = (await octokit.graphql(
-              RESOLVE_REVIEW_THREAD_MUTATION,
-              {
-                threadId,
-                headers: githubGraphqlScopeHeaders(target.repo),
-              }
-            )) as GithubResolveThreadMutation;
-            if (mutation.resolveReviewThread?.thread?.isResolved === true) {
-              resolved += 1;
-              log?.(`github resolve: thread ${threadId} resolved`);
-            } else {
-              failed += 1;
-              log?.(
-                `github resolve: thread ${threadId} mutation did not mark the thread resolved`
-              );
-            }
-          } catch (error) {
-            if (signal?.aborted) {
-              throw error;
-            }
-            failed += 1;
-            log?.(
-              `github resolve: thread ${threadId} failed: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        }
-        return {
-          requested: uniqueIds.length,
-          resolved,
-          failed,
-          detail: `resolved ${resolved} of ${uniqueIds.length} thread(s) on ${target.repo}#${target.prNumber} via host GitHub (${failed} failed)`,
-        };
-      } catch (error) {
-        if (signal?.aborted) {
-          throw error;
-        }
-        return {
-          requested: uniqueIds.length,
-          resolved,
-          failed: uniqueIds.length - resolved,
-          detail: `host GitHub thread resolve failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-      }
-    },
-  };
-}
-
-const REVIEW_THREAD_COMMENTS_FOR_PR_QUERY = `
-query ReviewThreadCommentsForPr(
-  $owner: String!
-  $repo: String!
-  $number: Int!
-  $cursor: String
-) {
-  repository(owner: $owner, name: $repo) {
-    pullRequest(number: $number) {
-      reviewThreads(first: ${REVIEW_THREADS_PAGE_SIZE}, after: $cursor) {
-        nodes {
-          id
-          isResolved
-          path
-          line
-          originalLine
-          startLine
-          originalStartLine
-          comments(first: 1) {
-            nodes {
-              databaseId
-              body
-              author { login __typename }
-              originalCommit { oid }
-            }
-          }
-        }
-        pageInfo { hasNextPage endCursor }
-      }
-    }
-  }
-}
-`;
-
-const RESOLVE_REVIEW_THREAD_MUTATION = `
-mutation ResolveReviewThread($threadId: ID!) {
-  resolveReviewThread(input: { threadId: $threadId }) {
-    thread { isResolved }
-  }
-}
-`;
-
-const GITHUB_VIEWER_LOGIN_QUERY = `
-query ViewerLogin {
-  viewer { login }
-}
-`;
-
-/**
- * The login the bound GitHub client itself acts as — the identity its posts
- * appear under. Works for installation tokens too (GraphQL `viewer` returns
- * the app's bot, e.g. `cursor[bot]`), so a reader can trust comments whose
- * author is provably the same identity it posts with, across every
- * environment's app (prod/staging/cloud-dev/custom) without hardcoding.
- * `repo` scopes the call through the Cursor github-proxy (the minted token
- * — and so the viewer — is per-repo there). Best-effort: `undefined` when
- * the lookup fails.
- */
-export async function fetchGithubSelfLogin(
-  github: HostGitHubClient,
-  args: { repo: string; signal?: AbortSignal; log?: ReviewCommentLog }
-): Promise<string | undefined> {
-  try {
-    const octokit = await github.getOctokit();
-    args.signal?.throwIfAborted();
-    const response = (await octokit.graphql(GITHUB_VIEWER_LOGIN_QUERY, {
-      headers: githubGraphqlScopeHeaders(args.repo),
-    })) as {
-      viewer?: { login?: string | null } | null;
-    };
-    const login = response.viewer?.login;
-    return typeof login === "string" && login !== "" ? login : undefined;
-  } catch (error) {
-    if (args.signal?.aborted) {
-      throw error;
-    }
-    args.log?.(
-      `github viewer lookup failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return undefined;
-  }
-}
-
-type OriginThreadJson = {
-  id?: string;
-  path?: string;
-  startLine?: number;
-  endLine?: number;
-  resolvedAt?: string;
-  version?: { headSha?: string };
-};
-
-/**
- * Public `OriginActor` proto3 JSON: a `user` / `app` / `serviceAccount`
- * oneof (see `origin_actor.proto`).
- */
-type OriginActorJson = {
-  user?: { id?: string; email?: string };
-  // Apps have no slug (they are id + display name); `slug` is being retired
-  // from the public actor and is never read here.
-  app?: { id?: string; displayName?: string };
-  serviceAccount?: { id?: string };
-};
-
-type OriginCommentJson = {
-  id?: string;
-  body?: string;
-  thread?: OriginThreadJson;
-  author?: OriginActorJson;
-};
-
-type OriginListCommentsJson = {
-  comments?: Array<OriginCommentJson | null>;
-  nextPageToken?: string;
-};
-
-/**
- * Origin public comment → {@link ListedReviewComment}. Only line-anchored
- * threads qualify (general-discussion and file-level threads carry no
- * position a review finding can be pinned to).
- */
-export function listedCommentFromOriginComment(
-  comment: OriginCommentJson
-): ListedReviewComment | undefined {
-  const thread = comment.thread;
-  if (
-    typeof comment.id !== "string" ||
-    comment.id === "" ||
-    typeof comment.body !== "string" ||
-    thread === undefined ||
-    typeof thread.id !== "string" ||
-    thread.id === "" ||
-    typeof thread.path !== "string" ||
-    thread.path === "" ||
-    typeof thread.startLine !== "number" ||
-    thread.startLine <= 0
-  ) {
-    return undefined;
-  }
-  const startLine = thread.startLine;
-  const endLine =
-    typeof thread.endLine === "number" && thread.endLine >= startLine
-      ? thread.endLine
-      : startLine;
-  const commitSha = thread.version?.headSha;
-  const author = comment.author;
-  const authorLogin =
-    author?.app?.displayName ?? author?.app?.id ?? author?.user?.email;
-  // App and service-account actors are machine identities; only a `user`
-  // actor is a human PR participant.
-  const authorIsBot =
-    author === undefined
-      ? undefined
-      : author.app !== undefined || author.serviceAccount !== undefined;
-  const authorAppId = author?.app?.id;
-  return {
-    commentId: comment.id,
-    threadId: thread.id,
-    resolved: typeof thread.resolvedAt === "string" && thread.resolvedAt !== "",
-    file: thread.path,
-    startLine,
-    endLine,
-    body: comment.body,
-    ...(typeof commitSha === "string" && commitSha !== "" ? { commitSha } : {}),
-    ...(typeof authorLogin === "string" && authorLogin !== ""
-      ? { authorLogin }
-      : {}),
-    ...(authorIsBot === undefined ? {} : { authorIsBot }),
-    ...(typeof authorAppId === "string" && authorAppId !== ""
-      ? { authorAppId }
-      : {}),
-  };
-}
-
-/**
- * Lists the PR's inline review threads through the Origin public REST API
- * (`GET …/pulls/{n}/comments`, paged). The flattened comment list is
- * ordered by creation time, so the first comment seen per thread is the
- * thread opener; replies are dropped.
- */
-export function createHostOriginReviewCommentLister(
-  origin: HostOriginReviewClient,
-  log?: ReviewCommentLog
-): ReviewCommentListerImplementation {
-  return {
-    async listReviewComments({ target, signal }) {
-      const [owner, repo] = target.repo.split("/", 2);
-      if (owner === undefined || repo === undefined || repo === "") {
-        log?.(`origin list: unparseable owner/repo "${target.repo}"`);
-        return [];
-      }
-      const basePath = `/v1/origin/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${target.prNumber}/comments`;
-      const comments: ListedReviewComment[] = [];
-      const seenThreads = new Set<string>();
-      let totalComments = 0;
-      let pageToken = "";
-      for (let page = 0; page < ORIGIN_COMMENTS_MAX_PAGES; page++) {
-        signal?.throwIfAborted();
-        const query =
-          pageToken === ""
-            ? `?pageSize=${ORIGIN_COMMENTS_PAGE_SIZE}`
-            : `?pageSize=${ORIGIN_COMMENTS_PAGE_SIZE}&pageToken=${encodeURIComponent(pageToken)}`;
-        const response = (await origin.request({
-          method: "GET",
-          path: `${basePath}${query}`,
-        })) as OriginListCommentsJson | null | undefined;
-        for (const comment of response?.comments ?? []) {
-          if (comment === null || comment === undefined) {
-            continue;
-          }
-          totalComments += 1;
-          const listed = listedCommentFromOriginComment(comment);
-          if (listed === undefined || seenThreads.has(listed.threadId)) {
-            // Not line-anchored, or a reply on a thread whose opener was
-            // already taken (the list is oldest-first).
-            continue;
-          }
-          seenThreads.add(listed.threadId);
-          comments.push(listed);
-        }
-        pageToken = response?.nextPageToken ?? "";
-        if (pageToken === "") {
-          break;
-        }
-      }
-      log?.(
-        `origin list: ${target.repo}#${target.prNumber} has ${totalComments} comment(s), ${comments.length} line-anchored thread opener(s)`
-      );
-      return comments;
-    },
-  };
-}
-
-/**
- * Resolves Origin comment threads through the public REST API
- * (`PATCH …/pulls/threads/{thread_id}` with `resolved: true`).
- */
-export function createHostOriginReviewThreadResolver(
-  origin: HostOriginReviewClient,
-  log?: ReviewCommentLog
-): ReviewThreadResolverImplementation {
-  return {
-    async resolveReviewThreads({ target, threadIds, signal }) {
-      const uniqueIds = [...new Set(threadIds.filter((id) => id !== ""))];
-      if (uniqueIds.length === 0) {
-        return skippedResolve("no threads to resolve");
-      }
-      const [owner, repo] = target.repo.split("/", 2);
-      if (owner === undefined || repo === undefined || repo === "") {
-        return skippedResolve("unparseable owner/repo from PR URL");
-      }
-      let resolved = 0;
-      let failed = 0;
-      for (const threadId of uniqueIds) {
-        signal?.throwIfAborted();
-        try {
-          await origin.request({
-            method: "PATCH",
-            path: `/v1/origin/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/threads/${encodeURIComponent(threadId)}`,
-            body: { resolved: true },
-          });
-          resolved += 1;
-          log?.(`origin resolve: thread ${threadId} resolved`);
-        } catch (error) {
-          if (signal?.aborted) {
-            throw error;
-          }
-          failed += 1;
-          log?.(
-            `origin resolve: thread ${threadId} failed: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      return {
-        requested: uniqueIds.length,
-        resolved,
-        failed,
-        detail: `resolved ${resolved} of ${uniqueIds.length} thread(s) on ${target.repo}#${target.prNumber} via host Origin (${failed} failed)`,
-      };
-    },
-  };
-}
-
-type ParsedGithubPrUrl = {
-  repo: string;
-  prNumber: number;
-};
-
-/**
- * Prepares the provider-neutral review payload used by local `gh` posting.
- */
-export function prepareReviewCommentsRequest(
-  args: ReviewCommentPostArgs
-):
-  | { kind: "prepared"; request: ReviewCommentsRequest }
-  | { kind: "skipped"; result: ReviewCommentPostResult } {
-  const target = parseGithubPrUrl(args.prUrl);
-  if (target.kind === "invalid") {
-    return { kind: "skipped", result: skipped(target.detail) };
-  }
-
-  return {
-    kind: "prepared",
-    request: {
-      provider: "github",
-      repo: target.value.repo,
-      prNumber: target.value.prNumber,
-      headSha: args.reviewedHeadSha,
-      message: args.message,
-      comments: args.comments,
-      cleanupPrevious: args.cleanupPrevious ?? true,
-    },
-  };
-}
-
-/**
- * Posts a PR review with the local `gh` credentials (`gh auth` / GITHUB_TOKEN /
- * GH_TOKEN). Does not use the security-bugbot comments service.
- */
-export function createLocalGhReviewPublisher(): ReviewCommentPublisherImplementation {
-  return {
-    async postReview(args) {
-      return postReviewViaLocalGh(args);
-    },
-  };
-}
-
-/**
- * Posts a PR review through the host GitHub client (Cursor account lease,
- * App installation token, or PAT). Prefer this on Cursor-deployed agents —
- * no separate GitHub write secret is required when `githubChannel({
- * cursorAccount })` is bound.
- */
-export function createHostGithubReviewPublisher(
-  github: HostGitHubClient
-): ReviewCommentPublisherImplementation {
-  return {
-    async postReview(args) {
-      return postReviewViaHostGithub(github, args);
-    },
-  };
-}
-
-/**
- * Pick the publisher for `prUrl`'s SCM. GitHub falls back to local `gh`
- * when no host client is bound (CLI). Origin has no local CLI publisher —
- * returns undefined unless an Origin REST client is provided.
- */
-export function createReviewCommentPublisher(args: {
-  prUrl: string;
-  github?: HostGitHubClient;
-  origin?: HostOriginReviewClient;
-}): ReviewCommentPublisherImplementation | undefined {
-  const target = resolveScmReviewTarget(args.prUrl);
-  if (target === undefined) {
-    return undefined;
-  }
-  switch (target.provider) {
-    case "github":
-      return args.github !== undefined
-        ? createHostGithubReviewPublisher(args.github)
-        : createLocalGhReviewPublisher();
-    case "origin":
-      return args.origin === undefined
-        ? undefined
-        : createHostOriginReviewPublisher(args.origin);
-  }
-}
-
-/**
- * Posts a COMMENT-verdict Origin review through the public REST API.
- *
- * Inline comments post as diff-anchored threads via the review's
- * `comments` field (`ReviewCommentInput` with an `InlineCommentAnchor`).
- * Origin rejects the whole request with INVALID_ARGUMENT when any anchor
- * is off the reviewed version's diff — the caller's body-only retry (the
- * same fallback GitHub's 422 takes) then folds the findings into the
- * review body.
- */
-export function createHostOriginReviewPublisher(
-  origin: HostOriginReviewClient
-): ReviewCommentPublisherImplementation {
-  return {
-    async postReview(args) {
-      return postReviewViaHostOrigin(origin, args);
-    },
-  };
-}
-
-async function postReviewViaHostGithub(
-  github: HostGitHubClient,
-  args: ReviewCommentPostArgs
-): Promise<ReviewCommentPostResult> {
-  const prepared = prepareReviewCommentsRequest(args);
-  if (prepared.kind === "skipped") {
-    return {
-      ...prepared.result,
-      publisher: "host_github",
-    };
-  }
-
-  const { request } = prepared;
-  const [owner, repo] = request.repo.split("/", 2);
-  if (owner === undefined || repo === undefined || repo === "") {
-    return skippedHost("unparseable owner/repo from PR URL");
-  }
-
-  try {
-    args.signal?.throwIfAborted();
-    const octokit = await github.getOctokit();
-    args.signal?.throwIfAborted();
-    const response = await octokit.rest.pulls.createReview({
-      owner,
-      repo,
-      pull_number: request.prNumber,
-      commit_id: request.headSha,
-      body: request.message,
-      event: "COMMENT",
-      comments: request.comments.map(toGithubPullRequestReviewComment),
-    });
-    const htmlUrl =
-      typeof response.data.html_url === "string"
-        ? response.data.html_url
-        : undefined;
-    const inlineCommentCount = request.comments.length;
-    return {
-      posted: true,
-      publisher: "host_github",
-      mode:
-        inlineCommentCount > 0
-          ? "review_with_inline_comments"
-          : "review_body_only",
-      inlineCommentCount,
-      detail: htmlUrl
-        ? `posted via host GitHub: ${htmlUrl}`
-        : `posted via host GitHub with ${inlineCommentCount} inline comment(s)`,
-      postedComments: await readPostedComments({
-        octokit,
-        owner,
-        repo,
-        prNumber: request.prNumber,
-        reviewId: response.data.id,
-        expected: inlineCommentCount,
-        signal: args.signal,
-      }),
-    };
-  } catch (error) {
-    if (args.signal?.aborted) {
-      throw error;
-    }
-    return skippedHost(
-      `host GitHub review post failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-
-/**
- * Ids of the inline comments a just-created review owns.
- *
- * `pulls.createReview` returns the review, not its comments.
- * `listCommentsForReview` either omits those rows or returns them with
- * `line` / `original_line` unset, so the line filter drops every id, the
- * store records no findings, and the next run cannot judge or resolve
- * those threads. Read the PR-wide list instead and keep only this
- * review's rows. Newest-first so a busy PR's older comments cannot push
- * ours past the page cap.
- * Best-effort: any failure yields an empty list, which costs the next run
- * its prior findings rather than risking a wrong id. Never throws — the
- * review is already posted by this point.
- */
-async function readPostedComments(args: {
-  octokit: Awaited<ReturnType<HostGitHubClient["getOctokit"]>>;
-  owner: string;
-  repo: string;
-  prNumber: number;
-  reviewId: number;
-  expected: number;
-  signal?: AbortSignal;
-}): Promise<PostedReviewComment[]> {
-  if (args.expected === 0) {
-    return [];
-  }
-  try {
-    const posted: PostedReviewComment[] = [];
-    for (let page = 1; page <= REVIEW_COMMENTS_MAX_PAGES; page++) {
-      args.signal?.throwIfAborted();
-      const response = await args.octokit.rest.pulls.listReviewComments({
-        owner: args.owner,
-        repo: args.repo,
-        pull_number: args.prNumber,
-        sort: "created",
-        direction: "desc",
-        per_page: REVIEW_COMMENTS_PAGE_SIZE,
-        page,
-      });
-      for (const comment of response.data) {
-        if (comment.pull_request_review_id !== args.reviewId) {
-          continue;
-        }
-        const line = comment.original_line ?? comment.line;
-        if (line === null || line === undefined) {
-          continue;
-        }
-        posted.push({ id: comment.id, file: comment.path, line });
-      }
-      if (
-        posted.length >= args.expected ||
-        response.data.length < REVIEW_COMMENTS_PAGE_SIZE
-      ) {
-        break;
-      }
-    }
-    return posted;
-  } catch {
-    return [];
-  }
-}
-
-async function postReviewViaLocalGh(
-  args: ReviewCommentPostArgs
-): Promise<ReviewCommentPostResult> {
-  const prepared = prepareReviewCommentsRequest(args);
-  if (prepared.kind === "skipped") {
-    return prepared.result;
-  }
-
-  const { request } = prepared;
-  const path = `repos/${request.repo}/pulls/${request.prNumber}/reviews`;
-  const payload = {
-    commit_id: request.headSha,
-    body: request.message,
-    event: "COMMENT",
-    comments: request.comments.map(toGithubReviewComment),
-  };
-
-  try {
-    args.signal?.throwIfAborted();
-    const response = await ghApiPostJson(path, payload, args.signal);
-    const htmlUrl =
-      typeof response.html_url === "string" ? response.html_url : undefined;
-    const inlineCommentCount = request.comments.length;
-    return {
-      posted: true,
-      publisher: "local_gh",
-      mode:
-        inlineCommentCount > 0
-          ? "review_with_inline_comments"
-          : "review_body_only",
-      inlineCommentCount,
-      detail: htmlUrl
-        ? `posted via local gh: ${htmlUrl}`
-        : `posted via local gh with ${inlineCommentCount} inline comment(s)`,
-    };
-  } catch (error) {
-    if (args.signal?.aborted) {
-      throw error;
-    }
-    return skipped(
-      `local gh review post failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-
-type GithubPullRequestReviewComment = {
-  path: string;
-  body: string;
-  line: number;
-  side: "RIGHT";
-  start_line?: number;
-  start_side?: "RIGHT";
-};
-
-function toGithubReviewComment(
-  comment: ReviewInlineComment
-): Record<string, string | number> {
-  return toGithubPullRequestReviewComment(comment);
-}
-
-function toGithubPullRequestReviewComment(
-  comment: ReviewInlineComment
-): GithubPullRequestReviewComment {
-  const body: GithubPullRequestReviewComment = {
-    path: comment.file,
-    body: comment.body,
-    line: comment.line,
-    side: "RIGHT",
-  };
-  if (
-    comment.start_line !== undefined &&
-    comment.start_line > 0 &&
-    comment.start_line !== comment.line
-  ) {
-    body.start_line = comment.start_line;
-    body.start_side = "RIGHT";
-  }
-  return body;
-}
-
-function skipped(detail: string): ReviewCommentPostResult {
-  return {
-    posted: false,
-    publisher: "local_gh",
-    mode: "skipped",
-    inlineCommentCount: 0,
-    detail,
-  };
-}
-
-function skippedHost(detail: string): ReviewCommentPostResult {
-  return {
-    posted: false,
-    publisher: "host_github",
-    mode: "skipped",
-    inlineCommentCount: 0,
-    detail,
-  };
-}
-
-function skippedOrigin(detail: string): ReviewCommentPostResult {
-  return {
-    posted: false,
-    publisher: "host_origin",
-    mode: "skipped",
-    inlineCommentCount: 0,
-    detail,
-  };
-}
-
-async function postReviewViaHostOrigin(
-  origin: HostOriginReviewClient,
-  args: ReviewCommentPostArgs
-): Promise<ReviewCommentPostResult> {
-  const target = resolveScmReviewTarget(args.prUrl);
-  if (target === undefined || target.provider !== "origin") {
-    return skippedOrigin("host Origin publisher only supports Origin PRs");
-  }
-  const [owner, repo] = target.repo.split("/", 2);
-  if (owner === undefined || repo === undefined || repo === "") {
-    return skippedOrigin("unparseable owner/repo from PR URL");
-  }
-
-  try {
-    args.signal?.throwIfAborted();
-    await origin.request({
-      method: "POST",
-      path: `/v1/origin/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${target.prNumber}/reviews`,
-      body: {
-        verdict: "comment",
-        body: args.message,
-        comments: args.comments.map(toOriginReviewCommentInput),
-      },
-    });
-    const inlineCommentCount = args.comments.length;
-    return {
-      posted: true,
-      publisher: "host_origin",
-      mode:
-        inlineCommentCount > 0
-          ? "review_with_inline_comments"
-          : "review_body_only",
-      inlineCommentCount,
-      detail: `posted Origin review on ${target.repo}#${target.prNumber} with ${inlineCommentCount} inline comment(s)`,
-    };
-  } catch (error) {
-    if (args.signal?.aborted) {
-      throw error;
-    }
-    return skippedOrigin(
-      `host Origin review post failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-
-type OriginReviewCommentInput = {
-  body: string;
-  inline: {
-    path: string;
-    side: "right";
-    startLine: number;
-    endLine?: number;
-  };
-};
-
-/** Provider-neutral inline comment → Origin `ReviewCommentInput`. */
-function toOriginReviewCommentInput(
-  comment: ReviewInlineComment
-): OriginReviewCommentInput {
-  const startLine =
-    comment.start_line !== undefined &&
-    comment.start_line > 0 &&
-    comment.start_line < comment.line
-      ? comment.start_line
-      : comment.line;
-  return {
-    body: comment.body,
-    inline: {
-      path: comment.file,
-      side: "right",
-      startLine,
-      ...(startLine === comment.line ? {} : { endLine: comment.line }),
-    },
-  };
-}
-
-function skippedResolve(detail: string): ResolveReviewThreadsResult {
-  return {
-    requested: 0,
-    resolved: 0,
-    failed: 0,
-    detail,
-  };
-}
-
-function parseGithubPrUrl(
-  prUrl: string
-):
-  | { kind: "valid"; value: ParsedGithubPrUrl }
-  | { kind: "invalid"; detail: string } {
-  let url: URL;
-  try {
-    url = new URL(prUrl);
-  } catch (error) {
-    return {
-      kind: "invalid",
-      detail: `unparseable PR URL: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-
-  if (url.hostname !== "github.com") {
-    return {
-      kind: "invalid",
-      detail: "local gh publisher only supports github.com PRs",
-    };
-  }
-
-  const parts = url.pathname.split("/").filter(Boolean);
-  if (parts.length !== 4 || parts[2] !== "pull") {
-    return {
-      kind: "invalid",
-      detail:
-        "unparseable PR URL: expected https://github.com/{owner}/{repo}/pull/{number}",
-    };
-  }
-
-  const prNumber = Number(parts[3]);
-  if (!Number.isInteger(prNumber) || prNumber <= 0) {
-    return {
-      kind: "invalid",
-      detail:
-        "unparseable PR URL: pull request number must be a positive integer",
-    };
-  }
-
-  return {
-    kind: "valid",
-    value: {
-      repo: `${parts[0]}/${parts[1]}`,
-      prNumber,
-    },
-  };
-}
-
-async function ghApiPostJson(
-  path: string,
-  payload: unknown,
-  signal?: AbortSignal
-): Promise<Record<string, unknown>> {
-  return new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(
-      "gh",
-      ["api", path, "--method", "POST", "--input", "-"],
-      {
-        env: { ...process.env, GH_PROMPT_DISABLED: "1" },
-        stdio: ["pipe", "pipe", "pipe"],
-      }
-    );
-    let stdout = "";
-    let stderr = "";
-    const onAbort = () => {
-      child.kill("SIGTERM");
-      rejectPromise(signal?.reason ?? new Error("aborted"));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (error) => {
-      signal?.removeEventListener("abort", onAbort);
-      rejectPromise(error);
-    });
-    child.on("close", (code) => {
-      signal?.removeEventListener("abort", onAbort);
-      if (code !== 0) {
-        rejectPromise(
-          new Error(
-            `gh api ${path} exited with ${code}: ${stderr.trim().slice(0, 2000)}`
-          )
-        );
-        return;
-      }
-      if (!stdout.trim()) {
-        resolvePromise({});
-        return;
-      }
-      try {
-        resolvePromise(JSON.parse(stdout) as Record<string, unknown>);
-      } catch (error) {
-        rejectPromise(
-          new Error(
-            `gh api ${path} returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`
-          )
-        );
-      }
-    });
-    child.stdin.end(JSON.stringify(payload));
-  });
-}