agent-reviews 0.1.0

package/lib/comments.js

@@ -0,0 +1,334 @@
+/**
+ * PR comment fetching, processing, and filtering
+ *
+ * Fetches all comment types (review comments, issue comments, reviews)
+ * from GitHub's API, processes them into a unified format, and provides
+ * filtering capabilities.
+ */
+
+const USER_AGENT = "agent-reviews";
+
+// ---------------------------------------------------------------------------
+// GitHub API helpers
+// ---------------------------------------------------------------------------
+
+async function findPRForBranch(owner, repo, branch, token, proxyFetch) {
+  const response = await proxyFetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls?head=${owner}:${branch}&state=open`,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": USER_AGENT,
+      },
+    }
+  );
+
+  if (!response.ok) {
+    throw new Error(`Failed to find PR: ${response.status}`);
+  }
+
+  const prs = await response.json();
+  return prs[0] || null;
+}
+
+// ---------------------------------------------------------------------------
+// Paginated fetch
+// ---------------------------------------------------------------------------
+
+async function fetchAllPages(url, token, proxyFetch) {
+  const results = [];
+  let nextUrl = url;
+
+  while (nextUrl) {
+    const response = await proxyFetch(nextUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": USER_AGENT,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`API request failed: ${response.status}`);
+    }
+
+    const data = await response.json();
+    results.push(...data);
+
+    // Check for next page in Link header
+    const linkHeader = response.headers.get("link");
+    nextUrl = null;
+    if (linkHeader) {
+      const nextMatch = linkHeader.match(/<([^>]+)>;\s*rel="next"/);
+      if (nextMatch) {
+        nextUrl = nextMatch[1];
+      }
+    }
+  }
+
+  return results;
+}
+
+async function fetchPRComments(owner, repo, prNumber, token, proxyFetch) {
+  const baseUrl = `https://api.github.com/repos/${owner}/${repo}`;
+
+  // Fetch all comment types in parallel
+  const [reviewComments, issueComments, reviews] = await Promise.all([
+    fetchAllPages(
+      `${baseUrl}/pulls/${prNumber}/comments?per_page=100`,
+      token,
+      proxyFetch
+    ),
+    fetchAllPages(
+      `${baseUrl}/issues/${prNumber}/comments?per_page=100`,
+      token,
+      proxyFetch
+    ),
+    fetchAllPages(
+      `${baseUrl}/pulls/${prNumber}/reviews?per_page=100`,
+      token,
+      proxyFetch
+    ),
+  ]);
+
+  return { reviewComments, issueComments, reviews };
+}
+
+// ---------------------------------------------------------------------------
+// Comment classification
+// ---------------------------------------------------------------------------
+
+/**
+ * Default meta-comment filters.
+ * These are auto-generated status updates, not actionable review findings.
+ * Users can extend this list via the `metaFilters` option.
+ */
+const DEFAULT_META_FILTERS = [
+  // Vercel deployment status
+  (user, body) => user === "vercel[bot]" && body.startsWith("[vc]:"),
+  // Supabase branch status
+  (user, body) => user === "supabase[bot]" && body.startsWith("[supa]:"),
+  // cursor[bot] summary (not the actual findings)
+  (user, body) =>
+    user === "cursor[bot]" &&
+    body.startsWith("Cursor Bugbot has reviewed your changes"),
+];
+
+function isMetaComment(user, body, metaFilters = DEFAULT_META_FILTERS) {
+  if (!body) return false;
+  return metaFilters.some((filter) => filter(user, body));
+}
+
+function isBot(username) {
+  if (!username) return false;
+  return (
+    username.endsWith("[bot]") ||
+    username === "Copilot" ||
+    username.includes("bot") ||
+    username === "github-actions"
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Processing
+// ---------------------------------------------------------------------------
+
+function processComments(data, options = {}) {
+  const { reviewComments, issueComments, reviews } = data;
+  const metaFilters = options.metaFilters || DEFAULT_META_FILTERS;
+
+  // Build a map of comment replies
+  const repliesMap = new Map();
+  for (const comment of reviewComments) {
+    if (comment.in_reply_to_id) {
+      if (!repliesMap.has(comment.in_reply_to_id)) {
+        repliesMap.set(comment.in_reply_to_id, []);
+      }
+      repliesMap.get(comment.in_reply_to_id).push({
+        id: comment.id,
+        user: comment.user?.login,
+        body: comment.body,
+        createdAt: comment.created_at,
+        isBot: isBot(comment.user?.login),
+      });
+    }
+  }
+
+  const processed = [];
+
+  // Process review comments (inline code comments)
+  for (const comment of reviewComments) {
+    if (comment.in_reply_to_id) continue;
+    if (isMetaComment(comment.user?.login, comment.body, metaFilters)) continue;
+
+    const replies = repliesMap.get(comment.id) || [];
+    const hasHumanReply = replies.some((r) => !r.isBot);
+    const hasAnyReply = replies.length > 0;
+
+    processed.push({
+      id: comment.id,
+      type: "review_comment",
+      user: comment.user?.login,
+      isBot: isBot(comment.user?.login),
+      path: comment.path,
+      line: comment.line || comment.original_line,
+      diffHunk: comment.diff_hunk || null,
+      body: comment.body,
+      createdAt: comment.created_at,
+      updatedAt: comment.updated_at,
+      url: comment.html_url,
+      replies,
+      hasHumanReply,
+      hasAnyReply,
+      isResolved: false,
+    });
+  }
+
+  // Process issue comments (general PR comments)
+  for (const comment of issueComments) {
+    if (isMetaComment(comment.user?.login, comment.body, metaFilters)) continue;
+
+    processed.push({
+      id: comment.id,
+      type: "issue_comment",
+      user: comment.user?.login,
+      isBot: isBot(comment.user?.login),
+      path: null,
+      line: null,
+      diffHunk: null,
+      body: comment.body,
+      createdAt: comment.created_at,
+      updatedAt: comment.updated_at,
+      url: comment.html_url,
+      replies: [],
+      hasHumanReply: false,
+      hasAnyReply: false,
+      isResolved: false,
+    });
+  }
+
+  // Process review bodies (only if they have content)
+  for (const review of reviews) {
+    if (isMetaComment(review.user?.login, review.body, metaFilters)) continue;
+    if (!review.body?.trim()) continue;
+
+    processed.push({
+      id: review.id,
+      type: "review",
+      user: review.user?.login,
+      isBot: isBot(review.user?.login),
+      path: null,
+      line: null,
+      diffHunk: null,
+      body: review.body,
+      state: review.state,
+      createdAt: review.submitted_at,
+      updatedAt: review.submitted_at,
+      url: review.html_url,
+      replies: [],
+      hasHumanReply: false,
+      hasAnyReply: false,
+      isResolved: review.state === "APPROVED" || review.state === "DISMISSED",
+    });
+  }
+
+  // Sort by date (newest first)
+  processed.sort(
+    (a, b) =>
+      new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+
+  return processed;
+}
+
+// ---------------------------------------------------------------------------
+// Filtering
+// ---------------------------------------------------------------------------
+
+function filterComments(comments, options) {
+  let filtered = comments;
+
+  if (options.botsOnly) {
+    filtered = filtered.filter((c) => c.isBot);
+  } else if (options.humansOnly) {
+    filtered = filtered.filter((c) => !c.isBot);
+  }
+
+  if (options.filter === "unresolved") {
+    filtered = filtered.filter((c) => !(c.isResolved || c.hasHumanReply));
+  } else if (options.filter === "unanswered") {
+    filtered = filtered.filter((c) => !c.hasAnyReply);
+  }
+
+  return filtered;
+}
+
+// ---------------------------------------------------------------------------
+// Reply
+// ---------------------------------------------------------------------------
+
+async function replyToComment(
+  owner,
+  repo,
+  prNumber,
+  commentId,
+  message,
+  token,
+  proxyFetch
+) {
+  // Try review comment reply endpoint first
+  const response = await proxyFetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/comments/${commentId}/replies`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": USER_AGENT,
+      },
+      body: JSON.stringify({ body: message }),
+    }
+  );
+
+  if (!response.ok) {
+    // Fallback to issue comment endpoint
+    const issueResponse = await proxyFetch(
+      `https://api.github.com/repos/${owner}/${repo}/issues/${prNumber}/comments`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          Accept: "application/vnd.github.v3+json",
+          "User-Agent": USER_AGENT,
+        },
+        body: JSON.stringify({
+          body: `> Re: comment ${commentId}\n\n${message}`,
+        }),
+      }
+    );
+
+    if (!issueResponse.ok) {
+      const error = await issueResponse.text();
+      throw new Error(`Failed to reply: ${issueResponse.status} - ${error}`);
+    }
+
+    return issueResponse.json();
+  }
+
+  return response.json();
+}
+
+module.exports = {
+  findPRForBranch,
+  fetchAllPages,
+  fetchPRComments,
+  processComments,
+  filterComments,
+  replyToComment,
+  isBot,
+  isMetaComment,
+  DEFAULT_META_FILTERS,
+};

package/lib/format.js

@@ -0,0 +1,166 @@
+/**
+ * Terminal output formatting for PR comments
+ */
+
+// ANSI colors
+const colors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+};
+
+function truncate(str, maxLength) {
+  if (!str) return "";
+  const oneLine = str.replace(/\n/g, " ").trim();
+  if (oneLine.length <= maxLength) return oneLine;
+  return `${oneLine.slice(0, maxLength - 3)}...`;
+}
+
+function getReplyStatus(comment) {
+  if (!comment.hasAnyReply) {
+    return `${colors.red}○ no reply${colors.reset}`;
+  }
+  if (comment.hasHumanReply) {
+    return `${colors.green}✓ replied${colors.reset}`;
+  }
+  return `${colors.yellow}⚡ bot replied${colors.reset}`;
+}
+
+function formatComment(comment) {
+  const typeColors = {
+    review_comment: colors.cyan,
+    issue_comment: colors.blue,
+    review: colors.magenta,
+  };
+
+  const typeLabels = {
+    review_comment: "CODE",
+    issue_comment: "COMMENT",
+    review: "REVIEW",
+  };
+
+  const typeColor = typeColors[comment.type] || colors.reset;
+  const typeLabel = typeLabels[comment.type] || comment.type.toUpperCase();
+  const userColor = comment.isBot ? colors.yellow : colors.green;
+  const replyStatus = getReplyStatus(comment);
+
+  let location = "";
+  if (comment.path) {
+    location = `${colors.dim}${comment.path}`;
+    if (comment.line) {
+      location += `:${comment.line}`;
+    }
+    location += colors.reset;
+  }
+
+  const lines = [
+    `${colors.bright}[${comment.id}]${colors.reset} ${typeColor}${typeLabel}${colors.reset} by ${userColor}${comment.user}${colors.reset} ${replyStatus}`,
+  ];
+
+  if (location) {
+    lines.push(`  ${location}`);
+  }
+
+  lines.push(`  ${colors.dim}${truncate(comment.body, 100)}${colors.reset}`);
+
+  if (comment.replies.length > 0) {
+    lines.push(
+      `  ${colors.dim}└ ${comment.replies.length} repl${comment.replies.length === 1 ? "y" : "ies"}${colors.reset}`
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function formatDetailedComment(comment) {
+  const typeLabels = {
+    review_comment: "CODE",
+    issue_comment: "COMMENT",
+    review: "REVIEW",
+  };
+  const typeLabel = typeLabels[comment.type] || comment.type.toUpperCase();
+  const replyStatus = comment.hasAnyReply
+    ? comment.hasHumanReply
+      ? "✓ replied"
+      : "⚡ bot replied"
+    : "○ no reply";
+
+  const lines = [];
+
+  lines.push(`=== Comment [${comment.id}] ===`);
+  lines.push(
+    `Type: ${typeLabel} | By: ${comment.user} | Status: ${replyStatus}`
+  );
+
+  if (comment.path) {
+    let location = `File: ${comment.path}`;
+    if (comment.line) location += `:${comment.line}`;
+    lines.push(location);
+  }
+
+  lines.push(`URL: ${comment.url}`);
+
+  if (comment.diffHunk) {
+    lines.push("");
+    lines.push("--- Code Context ---");
+    lines.push(comment.diffHunk);
+    lines.push("--- End Code Context ---");
+  }
+
+  lines.push("");
+  lines.push(comment.body || "(no body)");
+
+  if (comment.replies.length > 0) {
+    lines.push("");
+    lines.push(`--- Replies (${comment.replies.length}) ---`);
+    for (const reply of comment.replies) {
+      const date = reply.createdAt
+        ? new Date(reply.createdAt)
+            .toISOString()
+            .replace("T", " ")
+            .slice(0, 16)
+        : "unknown";
+      lines.push(`[${reply.id}] ${reply.user} (${date}):`);
+      lines.push(reply.body || "(no body)");
+      lines.push("");
+    }
+    lines.push("--- End Replies ---");
+  }
+
+  return lines.join("\n");
+}
+
+function formatOutput(comments, options) {
+  if (options.json) {
+    return JSON.stringify(comments, null, 2);
+  }
+
+  if (comments.length === 0) {
+    const filterDesc =
+      options.filter === "unresolved"
+        ? "unresolved "
+        : options.filter === "unanswered"
+          ? "unanswered "
+          : "";
+    return `${colors.green}No ${filterDesc}comments found.${colors.reset}`;
+  }
+
+  const header = `${colors.bright}Found ${comments.length} comment${comments.length === 1 ? "" : "s"}${colors.reset}\n`;
+  const formatted = comments.map((c) => formatComment(c)).join("\n\n");
+
+  return `${header}\n${formatted}`;
+}
+
+module.exports = {
+  colors,
+  truncate,
+  formatComment,
+  formatDetailedComment,
+  formatOutput,
+};

package/lib/github.js

@@ -0,0 +1,128 @@
+/**
+ * GitHub API utilities for agent-reviews
+ *
+ * Handles authentication, proxy support, and repository detection.
+ * Works in both local and cloud environments (HTTPS_PROXY, etc.).
+ */
+
+const { execSync } = require("node:child_process");
+const { existsSync, readFileSync } = require("node:fs");
+const path = require("node:path");
+
+// ---------------------------------------------------------------------------
+// Proxy-aware fetch (for cloud/corporate environments)
+// ---------------------------------------------------------------------------
+
+function getProxyFetch() {
+  const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy;
+  if (proxyUrl) {
+    try {
+      const { ProxyAgent, fetch: undiciFetch } = require("undici");
+      const agent = new ProxyAgent(proxyUrl);
+      return (url, options = {}) =>
+        undiciFetch(url, { ...options, dispatcher: agent });
+    } catch {
+      // undici not available, fall back to native fetch
+    }
+  }
+  return globalThis.fetch;
+}
+
+// ---------------------------------------------------------------------------
+// GitHub token resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve a GitHub token from (in priority order):
+ * 1. GITHUB_TOKEN env var
+ * 2. .env.local files in the repo root
+ * 3. `gh auth token` CLI
+ */
+function getGitHubToken() {
+  if (process.env.GITHUB_TOKEN) {
+    return process.env.GITHUB_TOKEN;
+  }
+
+  const root = getRepoRoot();
+  if (root) {
+    const envFile = path.join(root, ".env.local");
+    if (existsSync(envFile)) {
+      const content = readFileSync(envFile, "utf8");
+      const match = content.match(/^GITHUB_TOKEN=["']?([^"'\n]+)["']?/m);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
+
+  try {
+    const token = execSync("gh auth token", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (token) {
+      return token;
+    }
+  } catch {
+    // gh CLI not available or not authenticated
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Repository info
+// ---------------------------------------------------------------------------
+
+function getRepoRoot() {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function getRepoInfo() {
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      encoding: "utf8",
+    }).trim();
+
+    const sshMatch = remoteUrl.match(
+      /git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/
+    );
+    const httpsMatch = remoteUrl.match(
+      /github\.com\/([^/]+)\/(.+?)(?:\.git)?$/
+    );
+    const proxyMatch = remoteUrl.match(/\/git\/([^/]+)\/([^/]+)$/);
+
+    const match = sshMatch || httpsMatch || proxyMatch;
+    if (match) {
+      return { owner: match[1], repo: match[2].replace(/\.git$/, "") };
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null;
+}
+
+function getCurrentBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf8",
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  getProxyFetch,
+  getGitHubToken,
+  getRepoInfo,
+  getRepoRoot,
+  getCurrentBranch,
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "agent-reviews",
+  "version": "0.1.0",
+  "description": "CLI and Claude Code skill for managing GitHub PR review comments — list, filter, reply, and watch for bot findings",
+  "license": "MIT",
+  "author": "Paul Bakaus",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pbakaus/agent-reviews.git"
+  },
+  "keywords": [
+    "github",
+    "pull-request",
+    "code-review",
+    "cli",
+    "claude-code",
+    "ai-agent",
+    "pr-comments",
+    "review-bot"
+  ],
+  "bin": {
+    "agent-reviews": "bin/agent-reviews.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "skills/",
+    ".claude-plugin/"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}