claude-teammate 0.1.37 → 0.1.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-teammate",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "description": "CLI bootstrapper for Claude Teammate.",
   "license": "MIT",
   "type": "module",

package/src/claude.js

@@ -139,6 +139,34 @@ const GITHUB_PR_COMMENT_REVIEW_SCHEMA = {
   required: ["decision", "comment_body", "epic_facts", "epic_guardrails"]
 };
 
+const GITHUB_PR_REVIEW_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    summary: {
+      type: "string"
+    },
+    suggestions: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          file: { type: "string" },
+          line: { type: "number" },
+          side: { type: "string" },
+          body: { type: "string" },
+          classification: { type: "string", enum: ["Minor", "Major"] },
+          committable: { type: "boolean" },
+          suggestion: { type: "string" }
+        },
+        required: ["file", "line", "side", "body", "classification", "committable"]
+      }
+    }
+  },
+  required: ["summary", "suggestions"]
+};
+
 const EPIC_MEMORY_CLEANUP_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -502,6 +530,50 @@ export async function runClaudePullRequestCommentReview(input) {
   return validateGitHubPullRequestCommentReviewResult(parseClaudeOutput(stdout));
 }
 
+export async function runClaudePrReview(input) {
+  if (!input.repoPath) {
+    throw new Error("PR review requires a local repository path.");
+  }
+
+  const repoPaths = [input.repoPath];
+  await Promise.all(repoPaths.map((repoPath) => clearLocalPlaywrightMcpConfig(repoPath)));
+
+  const args = [
+    "--print",
+    "--model",
+    input.model || DEFAULT_MODEL,
+    "--permission-mode",
+    "default",
+    "--strict-mcp-config",
+    "--tools",
+    "Read,Grep,Glob",
+    "--effort",
+    "medium",
+    "--output-format",
+    "json",
+    "--json-schema",
+    JSON.stringify(GITHUB_PR_REVIEW_SCHEMA),
+    "--append-system-prompt",
+    buildGitHubPRReviewSystemPrompt(),
+    buildGitHubPRReviewUserPrompt(input)
+  ];
+
+  let stdout;
+
+  try {
+    ({ stdout } = await runClaudeCommand("claude", args, {
+      cwd: input.repoPath,
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: input.timeoutMs || DEFAULT_TIMEOUT_MS,
+      onSpawn: input.onSpawn
+    }));
+  } catch (error) {
+    throw new Error(formatClaudeInvocationError(error, input.timeoutMs || DEFAULT_TIMEOUT_MS));
+  }
+
+  return validateGitHubPrReviewResult(parseClaudeOutput(stdout));
+}
+
 export function parseClaudeOutput(output) {
   const trimmed = output.trim();
   if (!trimmed) {
@@ -522,6 +594,10 @@ export function parseClaudeOutput(output) {
       return direct;
     }
 
+    if ("summary" in direct && "suggestions" in direct) {
+      return direct;
+    }
+
     if ("result" in direct && typeof direct.result === "string") {
       return JSON.parse(direct.result);
     }
@@ -634,6 +710,27 @@ function validateGitHubPullRequestCommentReviewResult(result) {
   };
 }
 
+function validateGitHubPrReviewResult(result) {
+  if (!result || typeof result !== "object") {
+    throw new Error("Claude CLI returned an invalid GitHub PR review payload.");
+  }
+
+  return {
+    summary: String(result.summary ?? "").trim(),
+    suggestions: Array.isArray(result.suggestions)
+      ? result.suggestions.map((s) => ({
+          file: String(s.file ?? "").trim(),
+          line: Number(s.line) || 1,
+          side: String(s.side ?? "RIGHT").trim(),
+          body: String(s.body ?? "").trim(),
+          classification: ["Minor", "Major"].includes(s.classification) ? s.classification : "Minor",
+          committable: Boolean(s.committable),
+          suggestion: s.suggestion != null ? String(s.suggestion).trim() : undefined
+        }))
+      : []
+  };
+}
+
 function validateEpicMemoryCleanupResult(result) {
   if (!result || typeof result !== "object") {
     throw new Error("Claude CLI returned an invalid epic memory cleanup payload.");
@@ -931,6 +1028,20 @@ function buildGitHubPRCommentReviewSystemPrompt() {
   ].join(" ");
 }
 
+function buildGitHubPRReviewSystemPrompt() {
+  return [
+    "You are reviewing a GitHub pull request as a code reviewer.",
+    "The primary input is the unified diff provided inline.",
+    "You may also use Read, Grep, and Glob to read related code when the diff is ambiguous.",
+    "Do not edit files, do not run mutating commands, and do not implement anything.",
+    "Skip trivial style-only issues unless they introduce a real risk.",
+    "Classify each suggestion as Minor (non-blocking) or Major (should be addressed before merge).",
+    "Where possible, produce a committable suggestion with the corrected code.",
+    "Return a summary paragraph describing what the PR does, followed by a summary of all suggestions.",
+    "Return only structured output matching the provided schema."
+  ].join(" ");
+}
+
 function buildEpicMemoryCleanupSystemPrompt() {
   return [
     "You are updating epic memory for an autonomous engineering workflow.",
@@ -1082,6 +1193,22 @@ Instructions:
 - If blocked, return result=stuck with that summary explaining why it did not work.`;
 }
 
+function buildGitHubPRReviewUserPrompt(input) {
+  return `Review this GitHub pull request diff.
+
+Pull request number: ${input.pr?.number ?? ""}
+Pull request title:
+${input.pr?.title ?? ""}
+
+Repository path:
+${input.repoPath}
+
+Unified diff:
+${input.diff || "(empty)"}
+
+Review the diff carefully. Read related code files with Read, Grep, or Glob only when the diff alone is insufficient to judge correctness. Return a summary describing the PR and its suggestions.`;
+}
+
 function buildEpicMemoryCleanupUserPrompt(input) {
   return `Update this epic memory facts and guardrails and clean it up.
 

package/src/commands/worker.js

@@ -8,6 +8,7 @@ import {
   runClaudeEpicMemoryCleanup,
   runClaudeEpicMemorySummarize,
   runClaudeImplementation,
+  runClaudePrReview,
   runClaudePullRequestCommentReview,
   runClaudeGitHubIssueReview
 } from "../claude.js";
@@ -26,8 +27,10 @@ import {
   saveIssueMemory
 } from "../memory.js";
 import {
+  checkoutPullRequestBranch,
   commitAndPushRepoChanges,
   ensureBranchFromDefault,
+  ensureReviewRepo,
   hasUsableGitCheckout,
   listMissingRepoPaths,
   parseGitHubRepoUrl,
@@ -116,7 +119,12 @@ export async function runWorkerCommand({ projectRoot }) {
     draftPrCount: 0,
     draftPrs: [],
     prCommentReview: buildPrSubtaskState(previousState.prCommentReview),
-    prImplementation: buildPrSubtaskState(previousState.prImplementation)
+    prImplementation: buildPrSubtaskState(previousState.prImplementation),
+    lastReviewPollAt: null,
+    lastReviewSuccessAt: null,
+    lastReviewError: null,
+    reviewPrCount: 0,
+    reviewPrs: []
   };
 
   const updatePrSubtaskState = async (key, updates) => {
@@ -136,6 +144,7 @@ export async function runWorkerCommand({ projectRoot }) {
   let jiraPolling = false;
   let githubPolling = false;
   let prPolling = false;
+  let reviewPolling = false;
 
   const shutdown = async (signal) => {
     if (stopping) {
@@ -344,9 +353,94 @@ export async function runWorkerCommand({ projectRoot }) {
     }
   };
 
+  const pollReviewPrs = async () => {
+    if (reviewPolling || stopping) {
+      return;
+    }
+
+    reviewPolling = true;
+    state.lastReviewPollAt = new Date().toISOString();
+
+    try {
+      const processedPrs = [];
+      const prs = await github.listPrsNeedingReview();
+      let reviewedPrCount = prs.length;
+
+      for (const pr of prs) {
+        if (!pr.repoUrl) {
+          await logger.error("PR review skipped because repository URL is missing", {
+            pr: pr.number,
+            title: pr.title
+          });
+          reviewedPrCount -= 1;
+          continue;
+        }
+
+        try {
+          const repoPath = await ensureReviewRepo(pr.repoUrl, runtimePaths.reviewReposDir);
+          const prDetail = await github.fetchPullRequest(pr.repoUrl, pr.number);
+          await checkoutPullRequestBranch(repoPath, prDetail.headRef, prDetail.headRepoCloneUrl);
+
+          const diff = await github.fetchPullRequestDiff(pr.repoUrl, pr.number);
+          const result = await runClaudePrReview({
+            diff,
+            repoPath,
+            pr: prDetail,
+            timeoutMs: parseOptionalInt(values.CLAUDE_TIMEOUT_MS)
+          });
+
+          await github.createPullRequestReview(
+            pr.repoUrl,
+            pr.number,
+            result.summary,
+            result.suggestions,
+            "COMMENT"
+          );
+
+          await github.addLabelsToPullRequest(pr.repoUrl, pr.number, ["AI-reviewed"]);
+
+          processedPrs.push({
+            repoUrl: pr.repoUrl,
+            pullRequestNumber: String(pr.number),
+            pullRequestUrl: prDetail.url,
+            suggestionsCount: result.suggestions.length
+          });
+
+          await logger.info("PR review submitted", {
+            repo: pr.repoUrl,
+            pr: pr.number,
+            suggestions: result.suggestions.length
+          });
+        } catch (error) {
+          await logger.error("PR review failed", {
+            repo: pr.repoUrl,
+            pr: pr.number,
+            error
+          });
+        }
+      }
+
+      state.lastReviewSuccessAt = new Date().toISOString();
+      state.lastReviewError = null;
+      state.reviewPrCount = reviewedPrCount;
+      state.reviewPrs = processedPrs.slice(0, 20);
+      await writeState(runtimePaths.stateFile, state);
+      await logger.info("PR review poll complete", {
+        reviewed: reviewedPrCount
+      });
+    } catch (error) {
+      state.lastReviewError = error instanceof Error ? error.message : String(error);
+      await writeState(runtimePaths.stateFile, state);
+      await logger.error("PR review poll failed", { error });
+    } finally {
+      reviewPolling = false;
+    }
+  };
+
   await pollJira();
   await pollGitHub();
   await pollDraftPrs();
+  await pollReviewPrs();
   setInterval(() => {
     void pollJira();
   }, POLL_INTERVAL_MS);
@@ -356,6 +450,9 @@ export async function runWorkerCommand({ projectRoot }) {
   setInterval(() => {
     void pollDraftPrs();
   }, POLL_INTERVAL_MS);
+  setInterval(() => {
+    void pollReviewPrs();
+  }, POLL_INTERVAL_MS);
 }
 
 async function processJiraIssue({ issue, jira, github, botUser, config, projectRoot, runtimePaths, logger }) {

package/src/github.js

@@ -290,6 +290,85 @@ export function createGitHubClient(config) {
       return payload.default_branch;
     },
 
+    async listPrsNeedingReview() {
+      const query = "is:pr+is:open+review-requested:@me+-label:AI-reviewed";
+      const url = new URL("https://api.github.com/search/issues");
+      url.searchParams.set("q", query);
+      url.searchParams.set("per_page", "10");
+
+      const payload = await requestGitHub(url, config, { method: "GET" });
+      return Array.isArray(payload.items)
+        ? payload.items.map((item) => ({
+            repoUrl: mapRepositoryApiUrlToHtmlUrl(item.repository_url),
+            number: item.number,
+            title: item.title ?? ""
+          }))
+        : [];
+    },
+
+    async addLabelsToPullRequest(repoUrl, prNumber, labels) {
+      const repo = parseGitHubRepoUrl(repoUrl);
+      return requestGitHub(
+        `https://api.github.com/repos/${repo.owner}/${repo.name}/issues/${prNumber}/labels`,
+        config,
+        {
+          method: "POST",
+          body: JSON.stringify({ labels })
+        },
+        repo
+      );
+    },
+
+    async createPullRequestReview(repoUrl, prNumber, body, suggestions, event) {
+      const repo = parseGitHubRepoUrl(repoUrl);
+      const comments = Array.isArray(suggestions)
+        ? suggestions.map((s) => {
+            let commentBody = String(s.body || "").trim();
+            if (s.committable && s.suggestion) {
+              commentBody = `${commentBody}\n\n\`\`\`suggestion\n${s.suggestion}\n\`\`\``.trim();
+            }
+            return {
+              path: String(s.file || ""),
+              line: Number(s.line) || 1,
+              side: String(s.side || "RIGHT").toUpperCase(),
+              body: commentBody
+            };
+          })
+        : [];
+
+      return requestGitHub(
+        `https://api.github.com/repos/${repo.owner}/${repo.name}/pulls/${prNumber}/reviews`,
+        config,
+        {
+          method: "POST",
+          body: JSON.stringify({ body: String(body || "").trim(), event: event || "COMMENT", comments })
+        },
+        repo
+      );
+    },
+
+    async fetchPullRequestDiff(repoUrl, prNumber) {
+      const repo = parseGitHubRepoUrl(repoUrl);
+      const response = await fetch(
+        `https://api.github.com/repos/${repo.owner}/${repo.name}/pulls/${prNumber}`,
+        {
+          headers: {
+            Accept: "application/vnd.github.v3.diff",
+            Authorization: `Bearer ${config.GITHUB_PAT}`,
+            "User-Agent": "claude-teammate"
+          }
+        }
+      );
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(buildGitHubRequestError(response.status, repo, errorBody, {
+          method: "GET",
+          path: `/repos/${repo.owner}/${repo.name}/pulls/${prNumber}`
+        }));
+      }
+      return response.text();
+    },
+
     async createPullRequest(repoUrl, pullRequest) {
       const repo = parseGitHubRepoUrl(repoUrl);
       const payload = await requestGitHub(
@@ -316,6 +395,21 @@ export function createGitHubClient(config) {
   };
 }
 
+function mapRepositoryApiUrlToHtmlUrl(repositoryApiUrl) {
+  const value = String(repositoryApiUrl || "").trim();
+
+  if (!value) {
+    return "";
+  }
+
+  const match = value.match(/^https:\/\/api\.github\.com\/repos\/([^/]+)\/([^/]+)$/u);
+  if (!match) {
+    return value;
+  }
+
+  return `https://github.com/${match[1]}/${match[2]}`;
+}
+
 function mapGitHubIssue(payload, comments = []) {
   return {
     number: payload.number,
@@ -347,7 +441,8 @@ function mapGitHubPullRequestSummary(payload) {
       id: payload.user?.id ?? null
     },
     headRef: payload.head?.ref ?? "",
-    baseRef: payload.base?.ref ?? ""
+    baseRef: payload.base?.ref ?? "",
+    headRepoCloneUrl: payload.head?.repo?.clone_url ?? null
   };
 }
 

package/src/repo.js

@@ -54,6 +54,66 @@ export async function validateOrEnsureLocalRepo(repoUrl, reposDir, localPath = "
   return ensureLocalRepo(repoUrl, reposDir);
 }
 
+export async function ensureReviewRepo(repoUrl, reviewReposDir) {
+  const repo = parseGitHubRepoUrl(repoUrl);
+  const checkoutPath = path.join(reviewReposDir, repo.owner, repo.name);
+
+  if (await isUsableGitCheckout(checkoutPath)) {
+    await execGit(checkoutPath, ["checkout", "--", "."]);
+    await execGit(checkoutPath, ["clean", "-fd"]);
+    return checkoutPath;
+  }
+
+  await mkdir(path.dirname(checkoutPath), { recursive: true });
+  await execFileAsync("git", ["clone", repo.cloneUrl, checkoutPath], {
+    maxBuffer: 10 * 1024 * 1024,
+    env: buildGitEnv(repo.cloneUrl)
+  });
+
+  return checkoutPath;
+}
+
+export async function checkoutPullRequestBranch(repoPath, branchName, headRepoCloneUrl = null) {
+  const originUrl = await execGitOutput(repoPath, ["remote", "get-url", "origin"]);
+  const normalizedOrigin = originUrl.trim().replace(/\.git$/u, "").toLowerCase();
+  const normalizedHead = headRepoCloneUrl
+    ? headRepoCloneUrl.trim().replace(/\.git$/u, "").toLowerCase()
+    : null;
+
+  const isFork = normalizedHead && normalizedHead !== normalizedOrigin;
+
+  if (isFork) {
+    const remoteName = "pr-head";
+    let remoteExists = false;
+    try {
+      await execGitOutput(repoPath, ["remote", "get-url", remoteName]);
+      remoteExists = true;
+    } catch {
+      remoteExists = false;
+    }
+
+    if (remoteExists) {
+      await execGit(repoPath, ["remote", "set-url", remoteName, headRepoCloneUrl]);
+    } else {
+      await execFileAsync("git", ["remote", "add", remoteName, headRepoCloneUrl], {
+        cwd: repoPath,
+        maxBuffer: 10 * 1024 * 1024,
+        env: buildGitEnv(headRepoCloneUrl)
+      });
+    }
+
+    await execFileAsync("git", ["fetch", remoteName], {
+      cwd: repoPath,
+      maxBuffer: 10 * 1024 * 1024,
+      env: buildGitEnv(headRepoCloneUrl)
+    });
+    await execGit(repoPath, ["checkout", "-B", branchName, `${remoteName}/${branchName}`]);
+  } else {
+    await execGit(repoPath, ["fetch", "origin"]);
+    await execGit(repoPath, ["checkout", "-B", branchName, `origin/${branchName}`]);
+  }
+}
+
 export async function ensureBranchFromDefault(repoPath, branchName, baseBranch) {
   try {
     await execGit(repoPath, ["fetch", "origin", baseBranch, "--prune"]);

package/src/runtime.js

@@ -11,7 +11,8 @@ export function getRuntimePaths(projectRoot) {
     pidFile: path.join(runtimeDir, "worker.pid"),
     stateFile: path.join(runtimeDir, "state.json"),
     logFile: path.join(runtimeDir, "worker.log"),
-    reposDir: path.join(runtimeDir, "repos")
+    reposDir: path.join(runtimeDir, "repos"),
+    reviewReposDir: path.join(runtimeDir, "review-repos")
   };
 }