coderev-cli 1.0.16 → 1.0.18

package/README.md

@@ -26,6 +26,7 @@
   - [coderev cache（缓存管理）](#coderev-cache缓存管理)
   - [coderev config（配置管理）](#coderev-config配置管理)
   - [coderev init（初始化）](#coderev-init初始化)
+  - [coderev serve（GitHub App 自动审查）](#coderev-servegithub-app-自动审查)
 - [配置详解](#配置详解)
 - [平台集成](#平台集成)
 - [CI/CD 集成](#cicd-集成)
@@ -437,6 +438,49 @@ coderev init
 
 ---
 
+### coderev serve（GitHub App 自动审查）
+
+**作用**：启动 webhook 服务器，监听 GitHub App 的 pull_request 事件，自动对每个新 PR 进行代码审查。
+
+**适用场景**：团队仓库每个 PR 自动审查 / 开源项目自动反馈 / CI/CD 增强
+
+**参数**：
+
+| 参数 | 说明 | 示例 |
+|------|------|------|
+| `--port` | 服务器端口（默认 3000） | `--port 8080` |
+| `--app-id` | GitHub App ID | `--app-id 123456` |
+| `--private-key` | GitHub App 私钥 PEM | `--private-key "$(cat key.pem)"` |
+| `--webhook-secret` | Webhook 签名密钥 | `--webhook-secret xxx` |
+| `--review-mode` | 审查模式（comment/inline/check） | `--review-mode inline` |
+| `--auto-approve` | 无问题 PR 自动 approve | `--auto-approve` |
+| `--min-confidence` | 最低置信度阈值 | `--min-confidence 70` |
+
+**示例**：
+
+```bash
+# 启动服务器
+coderev serve --app-id 123456 --webhook-secret mysecret --private-key "$(cat /path/to/key.pem)"
+
+# 使用环境变量
+GITHUB_APP_ID=123456 GITHUB_APP_WEBHOOK_SECRET=mysecret coderev serve
+```
+
+**事件处理**：
+- `pull_request.opened` — 新 PR 自动审查
+- `pull_request.synchronize` — PR 更新时重新审查
+- `pull_request.reopened` — 重新审查
+- Draft PR 和 Bot PR 默认跳过
+
+**输出**：审查完成后自动：
+1. 发布 PR review comment（Markdown 格式）
+2. 设置 commit status（pending → success/failure/neutral）
+3. 可选 auto-approve（无问题的 PR）
+
+> 完整部署指南见 [docs/github-app.md](docs/github-app.md)
+
+---
+
 ## 配置详解
 
 ### 配置加载顺序

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coderev-cli",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Multi-agent AI code review for git -- parallel agents with confidence scoring",
   "main": "src/index.js",
   "bin": {

package/src/blame.js

@@ -0,0 +1,247 @@
+/**
+ * Git blame context analysis for coderev.
+ *
+ * Runs `git blame` on modified files to distinguish:
+ * - **New issues**: introduced in the current diff/commit
+ * - **Pre-existing issues**: already present before this change
+ *
+ * This helps reviewers focus on what's actually new vs. inherited debt.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Parse a unified diff into per-file line additions.
+ * @param {string} diff - The git diff text
+ * @returns {Array<{file: string, addedLines: number[]}>}
+ */
+function parseDiffAddedLines(diff) {
+  if (!diff || typeof diff !== 'string') return [];
+
+  const result = [];
+  const lines = diff.split('\n');
+  let currentFile = null;
+  let currentAdded = [];
+  let oldStart = 0, newStart = 0, oldCount = 0, newCount = 0;
+  let newLineOffset = 0;
+
+  for (const line of lines) {
+    // Detect file header
+    const fileMatch = line.match(/^\+\+\+ b\/(.*)/);
+    if (fileMatch) {
+      if (currentFile && currentAdded.length > 0) {
+        result.push({ file: currentFile, addedLines: [...new Set(currentAdded)].sort((a, b) => a - b) });
+      }
+      currentFile = fileMatch[1];
+      currentAdded = [];
+      continue;
+    }
+
+    // Chunk header: @@ -oldStart,oldCount +newStart,newCount @@
+    const chunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (chunkMatch) {
+      oldStart = parseInt(chunkMatch[1], 10);
+      oldCount = chunkMatch[2] ? parseInt(chunkMatch[2], 10) : 1;
+      newStart = parseInt(chunkMatch[3], 10);
+      newCount = chunkMatch[4] ? parseInt(chunkMatch[4], 10) : 1;
+      newLineOffset = newStart - 1;
+      continue;
+    }
+
+    // Track added lines (context or removed = old)
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      newLineOffset++;
+      currentAdded.push(newLineOffset);
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      // Removed lines don't advance new position
+      continue;
+    } else {
+      // Context line: advances both old and new
+      newLineOffset++;
+    }
+  }
+
+  // Push last file
+  if (currentFile && currentAdded.length > 0) {
+    result.push({ file: currentFile, addedLines: [...new Set(currentAdded)].sort((a, b) => a - b) });
+  }
+
+  return result;
+}
+
+/**
+ * Run `git blame` on a file for specific line numbers.
+ * @param {string} filePath - Path relative to git repo root
+ * @param {number[]} lineNumbers - Array of line numbers to blame
+ * @param {string} [repoPath] - Path to git repo (default: cwd)
+ * @returns {Promise<object>} Map of lineNumber -> { author, commit, date, isNew }
+ */
+function blameLines(filePath, lineNumbers, repoPath) {
+  return new Promise((resolve) => {
+    if (!lineNumbers || lineNumbers.length === 0) {
+      resolve({});
+      return;
+    }
+
+    const cwd = repoPath || process.cwd();
+    const absPath = path.resolve(cwd, filePath);
+
+    if (!fs.existsSync(absPath)) {
+      resolve({});
+      return;
+    }
+
+    try {
+      // Run git blame for specific lines, porcelain format
+      const lineArgs = lineNumbers.map(n => `-L ${n},${n}`).join(' ');
+      const cmd = `git blame --porcelain ${lineArgs} -- "${filePath}"`;
+
+      const stdout = execSync(cmd, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 10000,
+        maxBuffer: 10 * 1024 * 1024,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      const result = {};
+
+      // Parse porcelain format
+      const porcelainLines = stdout.split('\n');
+      let i = 0;
+
+      while (i < porcelainLines.length) {
+        const line = porcelainLines[i];
+        if (!line.trim()) { i++; continue; }
+
+        // Header line: commit-hash author-line file-line (or not)
+        const headerMatch = line.match(/^([a-f0-9]+)\s+(\d+)\s+(\d+)\s+(\d+)$/);
+        if (!headerMatch) { i++; continue; }
+
+        const commitHash = headerMatch[1];
+        const origLine = parseInt(headerMatch[2], 10);
+        const finalLine = parseInt(headerMatch[3], 10);
+        const numLines = parseInt(headerMatch[4], 10);
+
+        // Skip boundary (not committed yet)
+        if (commitHash === '0000000000000000000000000000000000000000') {
+          result[finalLine] = { commit: commitHash, author: '(uncommitted)', date: new Date(), isNew: true };
+          // Skip ahead the content lines
+          i += numLines + 1;
+          while (i < porcelainLines.length && porcelainLines[i].startsWith('\t')) { i++; }
+          continue;
+        }
+
+        // Read header fields until content
+        let author = '(unknown)';
+        let date = new Date(0);
+        let isNew = false;
+
+        i++;
+        while (i < porcelainLines.length && !porcelainLines[i].startsWith('\t')) {
+          const hdr = porcelainLines[i];
+          if (hdr.startsWith('author ')) {
+            author = hdr.slice(7);
+          } else if (hdr.startsWith('author-time ')) {
+            date = new Date(parseInt(hdr.slice(12), 10) * 1000);
+          } else if (hdr.startsWith('boundary')) {
+            // Boundary commit = root of history
+          }
+          i++;
+        }
+
+        // Line content (starts with \t)
+        if (i < porcelainLines.length && porcelainLines[i].startsWith('\t')) {
+          // Content line - skip
+        }
+
+        result[finalLine] = { commit: commitHash, author, date, isNew };
+
+        // Jump to next header (skip content lines)
+        while (i < porcelainLines.length && porcelainLines[i].startsWith('\t')) { i++; }
+      }
+
+      resolve(result);
+    } catch (err) {
+      // git blame failed (file not tracked, etc.)
+      resolve({});
+    }
+  });
+}
+
+/**
+ * Analyze a diff with git blame to classify issues.
+ * @param {string} diff - The git diff
+ * @param {object} [options] - Options
+ * @param {string} [options.repoPath] - Git repo path
+ * @returns {Promise<{fileContexts: Array}>}
+ */
+async function analyzeDiffContext(diff, options = {}) {
+  const files = parseDiffAddedLines(diff);
+  const fileContexts = [];
+
+  for (const fileEntry of files) {
+    const { file, addedLines } = fileEntry;
+    if (addedLines.length === 0) continue;
+
+    const blameMap = await blameLines(file, addedLines, options.repoPath);
+    const newLines = [];
+    const existingLines = [];
+
+    for (const lineNum of addedLines) {
+      if (blameMap[lineNum] && blameMap[lineNum].isNew) {
+        newLines.push(lineNum);
+      } else {
+        existingLines.push(lineNum);
+      }
+    }
+
+    fileContexts.push({
+      file,
+      totalNewLines: addedLines.length,
+      newLines,
+      existingLines,
+      existingCount: existingLines.length,
+      newCount: newLines.length,
+    });
+  }
+
+  return fileContexts;
+}
+
+/**
+ * Tag issues with blame context (new vs pre-existing).
+ * @param {Array} issues - List of review issues
+ * @param {Array} fileContexts - Output from analyzeDiffContext
+ * @returns {Array} Tagged issues with `isNew` field
+ */
+function tagIssuesWithBlame(issues, fileContexts) {
+  if (!issues || !fileContexts) return issues || [];
+
+  const lineMap = {};
+  for (const ctx of fileContexts) {
+    for (const ln of ctx.newLines) {
+      lineMap[`${ctx.file}:${ln}`] = true;
+    }
+  }
+
+  return issues.map(issue => {
+    if (!issue.file || !issue.line) {
+      return { ...issue, isNew: null }; // Can't determine
+    }
+    const key = `${issue.file}:${issue.line}`;
+    return {
+      ...issue,
+      isNew: lineMap[key] || false,
+    };
+  });
+}
+
+module.exports = {
+  parseDiffAddedLines,
+  blameLines,
+  analyzeDiffContext,
+  tagIssuesWithBlame,
+};