diffcop 0.0.0-stage → 0.1.0

package/src/commands/review.ts

@@ -0,0 +1,220 @@
+import { defineCommand } from "citty";
+import { z } from "zod";
+import {
+  ClaudeCodeReviewerAgent,
+  EFFORTS,
+} from "@/agent/claude-code/claude-code-agent";
+import { GitRepository } from "@/context/git/git-repository";
+import { readPullRequestContext } from "@/context/github/pull-request-context";
+import type { PullRequestContext } from "@/context/github/pull-request-context";
+import { PullRequestFetcher } from "@/context/github/pull-request-fetcher";
+import { ReviewContextCollector } from "@/context/review-context-collector";
+import { ReviewPromptBuilder } from "@/prompt/review-prompt-builder";
+import { ConsoleReporter } from "@/reporter/console/console-reporter";
+import { JsonReporter } from "@/reporter/console/json-reporter";
+import { GitHubClient } from "@/github/github-client";
+import { GitHubReporter } from "@/reporter/github/github-reporter";
+import { ReviewCommentFormatter } from "@/reporter/github/review-comment-formatter";
+import { StickyComment } from "@/reporter/github/sticky-comment";
+import type { ReviewReporter } from "@/reporter/review-reporter";
+import { ChangeSizeLimit } from "@/review/change-size-limit";
+import { CodeReviewer } from "@/review/code-reviewer";
+
+const REPORTERS = ["console", "json", "github"] as const;
+
+type ReporterName = (typeof REPORTERS)[number];
+
+function parsePositiveInt(flag: string, value: string) {
+  const result = z.coerce.number().int().positive().safeParse(value);
+  if (!result.success) {
+    throw new Error(`--${flag} must be a positive integer, not "${value}".`);
+  }
+  return result.data;
+}
+
+function createGitHubClient(pr: PullRequestContext | undefined) {
+  const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+  if (!pr || !token) {
+    return undefined;
+  }
+  return new GitHubClient({
+    auth: token,
+    baseUrl: pr.apiUrl,
+  });
+}
+
+function createPullRequestSource(
+  pr: PullRequestContext | undefined,
+  github: GitHubClient | undefined,
+) {
+  if (!pr) {
+    return undefined;
+  }
+  if (!github) {
+    process.stderr.write(
+      "No GITHUB_TOKEN or GH_TOKEN, so the review won't see the PR's description, comments or reviews.\n",
+    );
+    return undefined;
+  }
+  return new PullRequestFetcher(pr, github);
+}
+
+function createGitHubReporter(
+  pr: PullRequestContext | undefined,
+  github: GitHubClient | undefined,
+  debug: boolean,
+) {
+  if (!pr) {
+    throw new Error(
+      "--reporter github only works in a GitHub Actions pull_request run.",
+    );
+  }
+  if (!github) {
+    throw new Error(
+      "--reporter github needs GITHUB_TOKEN or GH_TOKEN to post the review.",
+    );
+  }
+  return new GitHubReporter(
+    new StickyComment(pr, github),
+    new ReviewCommentFormatter(pr, {
+      secrets: [
+        process.env.GITHUB_TOKEN,
+        process.env.GH_TOKEN,
+        process.env.ANTHROPIC_API_KEY,
+        process.env.CLAUDE_CODE_OAUTH_TOKEN,
+      ],
+    }),
+    process.stderr,
+    { debug: debug },
+  );
+}
+
+function createReporter(
+  name: ReporterName,
+  pr: PullRequestContext | undefined,
+  github: GitHubClient | undefined,
+  debug: boolean,
+): ReviewReporter {
+  switch (name) {
+    case "console":
+      return new ConsoleReporter(process.stdout, process.stderr, {
+        colors: process.stdout.isTTY,
+        columns: process.stdout.columns,
+      });
+    case "json":
+      return new JsonReporter(process.stdout);
+    case "github":
+      return createGitHubReporter(pr, github, debug);
+  }
+}
+
+export default defineCommand({
+  meta: {
+    name: "review",
+    description: "Review local changes against a base branch",
+  },
+  args: {
+    prompt: {
+      type: "positional",
+      description: "What to ask the reviewer",
+      required: true,
+    },
+    base: {
+      type: "string",
+      description:
+        "Base ref to diff against (default: the PR's base in GitHub Actions, else origin/HEAD, else main)",
+    },
+    cwd: {
+      type: "string",
+      description: "Repository directory",
+      default: ".",
+    },
+    model: {
+      type: "string",
+      description: "Model override",
+    },
+    maxTurns: {
+      type: "string",
+      description: "Maximum agent turns per pass (default: Claude Code's)",
+    },
+    maxLines: {
+      type: "string",
+      description:
+        "Warn when the change has more added plus deleted lines than this, lockfiles aside",
+      default: "1000",
+    },
+    maxFiles: {
+      type: "string",
+      description:
+        "Warn when the change touches more files than this, lockfiles aside",
+      default: "20",
+    },
+    effort: {
+      type: "enum",
+      options: [...EFFORTS],
+      description: "How hard the model thinks (default: Claude Code's)",
+    },
+    reporter: {
+      type: "enum",
+      options: [...REPORTERS],
+      default: "console",
+      description:
+        "Where the review goes: console shows progress then the findings, json prints one object when done, github keeps it in a PR comment (GitHub Actions only; needs GITHUB_TOKEN or GH_TOKEN)",
+    },
+    debug: {
+      type: "boolean",
+      description:
+        "With --reporter github, also log tool calls and thinking time",
+    },
+  },
+  // Composition root: the only place that picks concrete implementations.
+  run: async function ({ args }) {
+    let maxTurns: number | undefined;
+    if (args.maxTurns !== undefined) {
+      maxTurns = parsePositiveInt("maxTurns", args.maxTurns);
+    }
+    const sizeLimit = new ChangeSizeLimit({
+      maxLines: parsePositiveInt("maxLines", args.maxLines),
+      maxFiles: parsePositiveInt("maxFiles", args.maxFiles),
+    });
+    const pr = await readPullRequestContext(process.env);
+    const github = createGitHubClient(pr);
+    // Built before the review runs so a misconfigured job fails fast.
+    const reporter = createReporter(
+      args.reporter,
+      pr,
+      github,
+      args.debug === true,
+    );
+
+    const reviewer = new CodeReviewer(
+      new ReviewContextCollector(
+        new GitRepository(args.cwd),
+        createPullRequestSource(pr, github),
+      ),
+      new ReviewPromptBuilder(),
+      new ClaudeCodeReviewerAgent({
+        model: args.model,
+        maxTurns: maxTurns,
+        effort: args.effort,
+      }),
+      reporter,
+      sizeLimit,
+    );
+
+    // Actions sends SIGINT, then SIGTERM, when a job is cancelled or times out.
+    const abort = new AbortController();
+    process.once("SIGINT", () => {
+      abort.abort();
+    });
+    process.once("SIGTERM", () => {
+      abort.abort();
+    });
+
+    await reviewer.review({
+      request: args.prompt,
+      base: args.base,
+      abortSignal: abort.signal,
+    });
+  },
+});

package/src/context/git/git-repository.ts

@@ -0,0 +1,74 @@
+import { $ } from "bun";
+import type { Repository } from "@/context/repository";
+
+function lines(text: string) {
+  return text.split("\n").filter(Boolean);
+}
+
+async function git(cwd: string, args: string[]) {
+  return (await $`git ${args}`.cwd(cwd).quiet().text()).trim();
+}
+
+export class GitRepository implements Repository {
+  readonly #cwd: string;
+  #root: Promise<string> | undefined;
+
+  constructor(cwd: string) {
+    this.#cwd = cwd;
+  }
+
+  // Every command runs from here, no matter where diffcop was started.
+  async root() {
+    this.#root ??= git(this.#cwd, ["rev-parse", "--show-toplevel"]).catch(
+      () => {
+        throw new Error(`Not a git repository: ${this.#cwd}`);
+      },
+    );
+    return this.#root;
+  }
+
+  async defaultBase() {
+    // Resolve the root outside the fallback so "not a git repository" isn't
+    // mistaken for a missing origin/HEAD.
+    const root = await this.root();
+    return git(root, ["rev-parse", "--abbrev-ref", "origin/HEAD"]).catch(() => {
+      return "main";
+    });
+  }
+
+  async mergeBase(ref: string) {
+    return this.#run("merge-base", "HEAD", ref);
+  }
+
+  async currentBranch() {
+    return this.#run("rev-parse", "--abbrev-ref", "HEAD");
+  }
+
+  async commitsSince(ref: string) {
+    return lines(await this.#run("log", "--oneline", `${ref}..HEAD`));
+  }
+
+  // Covers the working tree, not just commits, so uncommitted edits count.
+  async changedFilesSince(ref: string) {
+    return lines(await this.#run("diff", "--numstat", ref)).map((line) => {
+      const [additions = "0", deletions = "0", path = ""] = line.split("\t");
+      return {
+        path: path,
+        additions: Number(additions) || 0,
+        deletions: Number(deletions) || 0,
+      };
+    });
+  }
+
+  async diffSince(ref: string) {
+    return this.#run("diff", ref);
+  }
+
+  async hashObject(path: string) {
+    return this.#run("hash-object", "--", path);
+  }
+
+  async #run(...args: string[]) {
+    return git(await this.root(), args);
+  }
+}

package/src/context/github/pull-request-context.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+
+export interface PullRequestContext {
+  apiUrl: string;
+  repo: string;
+  number: number;
+  headSha: string;
+  // Title and body as of the event, so edits made after it can't reach the prompt.
+  title: string;
+  body: string;
+  action?: string;
+  // Comments and reviews created or edited from this time on are left out.
+  triggerTime?: string;
+  runId?: string;
+  runUrl?: string;
+}
+
+const pullRequestEvent = z.object({
+  action: z.string().optional(),
+  pull_request: z.object({
+    number: z.number(),
+    title: z.string(),
+    body: z.string().nullish(),
+    created_at: z.string().optional(),
+    updated_at: z.string().optional(),
+    head: z.object({ sha: z.string() }),
+  }),
+});
+
+// Same rule as claude-code-action's extractTriggerTimestamp for pull_request
+// events: an opened PR's creation, otherwise its last update (the push).
+function triggerTime(
+  action: string | undefined,
+  pullRequest: { created_at?: string; updated_at?: string },
+) {
+  if (action === "opened") {
+    return pullRequest.created_at ?? pullRequest.updated_at;
+  }
+  return pullRequest.updated_at ?? pullRequest.created_at;
+}
+
+export async function readPullRequestContext(
+  env: Record<string, string | undefined> = process.env,
+): Promise<PullRequestContext | undefined> {
+  const { GITHUB_ACTIONS, GITHUB_EVENT_PATH, GITHUB_REPOSITORY } = env;
+  if (GITHUB_ACTIONS !== "true" || !GITHUB_EVENT_PATH || !GITHUB_REPOSITORY) {
+    return undefined;
+  }
+
+  // An unreadable or malformed payload counts as "not a pull request" too.
+  const event = pullRequestEvent.safeParse(
+    await Bun.file(GITHUB_EVENT_PATH)
+      .json()
+      .catch(() => {
+        return undefined;
+      }),
+  );
+  if (!event.success) {
+    return undefined;
+  }
+
+  const { action, pull_request: pullRequest } = event.data;
+  const runId = env.GITHUB_RUN_ID;
+  const serverUrl = env.GITHUB_SERVER_URL ?? "https://github.com";
+  let runUrl: string | undefined;
+  if (runId) {
+    runUrl = `${serverUrl}/${GITHUB_REPOSITORY}/actions/runs/${runId}`;
+  }
+  return {
+    apiUrl: env.GITHUB_API_URL ?? "https://api.github.com",
+    repo: GITHUB_REPOSITORY,
+    number: pullRequest.number,
+    headSha: pullRequest.head.sha,
+    title: pullRequest.title,
+    body: pullRequest.body ?? "",
+    action: action,
+    triggerTime: triggerTime(action, pullRequest),
+    runId: runId,
+    runUrl: runUrl,
+  };
+}

package/src/context/github/pull-request-data.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+
+// The shape of claude-code-action's PR_QUERY, trimmed to the fields its prompt uses.
+
+const author = z.object({ login: z.string() }).nullable();
+
+const pullRequestComment = z.object({
+  body: z.string(),
+  author: author,
+  createdAt: z.string(),
+  updatedAt: z.string().optional(),
+  lastEditedAt: z.string().nullish(),
+  isMinimized: z.boolean(),
+});
+
+export type PullRequestComment = z.infer<typeof pullRequestComment>;
+
+const pullRequestReviewComment = pullRequestComment.extend({
+  path: z.string(),
+  line: z.number().nullable(),
+  diffHunk: z.string().optional(),
+});
+
+export type PullRequestReviewComment = z.infer<typeof pullRequestReviewComment>;
+
+const pullRequestReview = z.object({
+  author: author,
+  body: z.string(),
+  state: z.string(),
+  submittedAt: z.string(),
+  updatedAt: z.string().optional(),
+  lastEditedAt: z.string().nullish(),
+  comments: z.object({ nodes: z.array(pullRequestReviewComment) }),
+});
+
+export type PullRequestReview = z.infer<typeof pullRequestReview>;
+
+const pullRequestFile = z.object({
+  path: z.string(),
+  additions: z.number(),
+  deletions: z.number(),
+  changeType: z.string(),
+});
+
+export type PullRequestFile = z.infer<typeof pullRequestFile>;
+
+export type PullRequestFileWithSha = PullRequestFile & { sha: string };
+
+const pullRequestFiles = z.object({
+  totalCount: z.number(),
+  nodes: z.array(pullRequestFile),
+});
+
+export type PullRequestFiles = z.infer<typeof pullRequestFiles>;
+
+export const pullRequestData = z.object({
+  repo: z.string(),
+  number: z.number(),
+  action: z.string().optional(),
+  title: z.string(),
+  body: z.string(),
+  author: author,
+  headRefName: z.string(),
+  baseRefName: z.string(),
+  state: z.string(),
+  additions: z.number(),
+  deletions: z.number(),
+  labels: z.object({ nodes: z.array(z.object({ name: z.string() })) }),
+  commits: z.object({ totalCount: z.number() }),
+  // null when GitHub won't list the files, usually because the diff is too large.
+  files: pullRequestFiles.nullable(),
+  comments: z.object({ nodes: z.array(pullRequestComment) }),
+  reviews: z.object({ nodes: z.array(pullRequestReview) }),
+});
+
+export type PullRequestData = z.infer<typeof pullRequestData>;
+
+export interface PullRequestSource {
+  fetch(): Promise<PullRequestData>;
+}

package/src/context/github/pull-request-fetcher.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import type { GitHubClient } from "@/github/github-client";
+import { unwrapResponse } from "@/github/unwrap-response";
+import type { PullRequestContext } from "@/context/github/pull-request-context";
+import { pullRequestData } from "@/context/github/pull-request-data";
+import type {
+  PullRequestData,
+  PullRequestSource,
+} from "@/context/github/pull-request-data";
+
+const COMMENT_FIELDS = `
+  body
+  author { login }
+  createdAt
+  updatedAt
+  lastEditedAt
+  isMinimized`;
+
+const PR_QUERY = `
+  query($owner: String!, $repo: String!, $number: Int!) {
+    repository(owner: $owner, name: $repo) {
+      pullRequest(number: $number) {
+        author { login }
+        baseRefName
+        headRefName
+        additions
+        deletions
+        state
+        labels(first: 100) { nodes { name } }
+        commits(first: 100) { totalCount }
+        files(first: 100) {
+          totalCount
+          nodes { path additions deletions changeType }
+        }
+        comments(first: 100) { nodes { ${COMMENT_FIELDS} } }
+        reviews(first: 100) {
+          nodes {
+            author { login }
+            body
+            state
+            submittedAt
+            updatedAt
+            lastEditedAt
+            comments(first: 100) {
+              nodes { ${COMMENT_FIELDS} path line diffHunk }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+const queryResult = z.object({
+  repository: z.object({
+    pullRequest: pullRequestData
+      .omit({
+        repo: true,
+        number: true,
+        action: true,
+        title: true,
+        body: true,
+      })
+      .nullable(),
+  }),
+});
+
+interface Timestamps {
+  updatedAt?: string;
+  lastEditedAt?: string | null;
+}
+
+// Port of claude-code-action's filterCommentsToTriggerTime: anything created or
+// edited at or after the trigger could have been planted after the push.
+function existedBefore(
+  createdAt: string,
+  { updatedAt, lastEditedAt }: Timestamps,
+  triggerTime: string | undefined,
+) {
+  if (!triggerTime) {
+    return true;
+  }
+  const trigger = new Date(triggerTime).getTime();
+  if (new Date(createdAt).getTime() >= trigger) {
+    return false;
+  }
+  const lastEdit = lastEditedAt || updatedAt;
+  return !lastEdit || new Date(lastEdit).getTime() < trigger;
+}
+
+// claude-code-action's fetchGitHubData, for a pull_request event.
+export class PullRequestFetcher implements PullRequestSource {
+  readonly #pr: PullRequestContext;
+  readonly #github: GitHubClient;
+
+  constructor(pr: PullRequestContext, github: GitHubClient) {
+    this.#pr = pr;
+    this.#github = github;
+  }
+
+  async fetch(): Promise<PullRequestData> {
+    const { repo, number, action, title, body, triggerTime } = this.#pr;
+    const [owner = "", name = ""] = repo.split("/");
+    const result = unwrapResponse(
+      queryResult.safeParse(
+        await this.#github.graphql<unknown>(PR_QUERY, {
+          owner: owner,
+          repo: name,
+          number: number,
+        }),
+      ),
+      "GitHub's pull request query",
+    );
+    const pullRequest = result.repository.pullRequest;
+    if (!pullRequest) {
+      throw new Error(`Pull request ${repo}#${number} not found.`);
+    }
+
+    const reviews = pullRequest.reviews.nodes
+      .filter((review) => {
+        return existedBefore(review.submittedAt, review, triggerTime);
+      })
+      .map((review) => {
+        return {
+          ...review,
+          comments: {
+            nodes: review.comments.nodes.filter((comment) => {
+              return existedBefore(comment.createdAt, comment, triggerTime);
+            }),
+          },
+        };
+      });
+
+    return {
+      ...pullRequest,
+      repo: repo,
+      number: number,
+      action: action,
+      title: title,
+      body: body,
+      comments: {
+        nodes: pullRequest.comments.nodes.filter((comment) => {
+          return existedBefore(comment.createdAt, comment, triggerTime);
+        }),
+      },
+      reviews: { nodes: reviews },
+    };
+  }
+}

package/src/context/repository.ts

@@ -0,0 +1,16 @@
+export interface ChangedFile {
+  path: string;
+  additions: number;
+  deletions: number;
+}
+
+export interface Repository {
+  root(): Promise<string>;
+  defaultBase(): Promise<string>;
+  mergeBase(ref: string): Promise<string>;
+  currentBranch(): Promise<string>;
+  commitsSince(ref: string): Promise<string[]>;
+  changedFilesSince(ref: string): Promise<ChangedFile[]>;
+  diffSince(ref: string): Promise<string>;
+  hashObject(path: string): Promise<string>;
+}