@alibaba-group/open-code-review 1.1.8 → 1.1.9

package/examples/github_actions/ocr-review.yml

@@ -0,0 +1,321 @@
+# OpenCodeReview - GitHub Actions PR Auto-Review Demo
+#
+# This workflow automatically reviews pull requests using OpenCodeReview
+# and posts review comments directly on the PR.
+#
+# Triggers:
+#   - PR opened, synchronized, or reopened
+#   - Comment on PR containing '/open-code-review' or '@open-code-review'
+#
+# Required secrets:
+#   OCR_LLM_URL        - LLM API endpoint (e.g., https://api.openai.com/v1/chat/completions)
+#   OCR_LLM_AUTH_TOKEN - Authentication token for the LLM API
+#
+# Optional secrets:
+#   OCR_LLM_MODEL      - Model name (default: gpt-4o)
+#
+# Note: GITHUB_TOKEN is automatically provided by GitHub Actions.
+
+name: OpenCodeReview PR Review
+
+on:
+  pull_request:
+    types: [opened]
+  issue_comment:
+    types: [created]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  code-review:
+    runs-on: ubuntu-latest
+    # Run on PR events, or on comments starting with trigger keywords
+    if: |
+      github.event_name == 'pull_request' ||
+      (github.event_name == 'issue_comment' && github.event.issue.pull_request && startsWith(github.event.comment.body, '/open-code-review')) ||
+      (github.event_name == 'issue_comment' && github.event.issue.pull_request && startsWith(github.event.comment.body, '@open-code-review'))
+    steps:
+      - name: Get PR context
+        id: pr-context
+        if: github.event_name != 'pull_request'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            // For issue_comment events, get PR info
+            const prNumber = context.issue.number;
+            const { data: pullRequest } = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: prNumber
+            });
+            core.setOutput('base_ref', pullRequest.base.ref);
+            core.setOutput('head_ref', pullRequest.head.ref);
+            core.setOutput('head_sha', pullRequest.head.sha);
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Full history needed for merge-base diff
+          ref: ${{ github.event_name != 'pull_request' && steps.pr-context.outputs.head_sha || '' }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install OpenCodeReview
+        run: npm install -g @alibaba-group/open-code-review
+
+      - name: Configure OCR
+        run: |
+          ocr config set llm.url ${{ secrets.OCR_LLM_URL }}
+          ocr config set llm.auth_token ${{ secrets.OCR_LLM_AUTH_TOKEN }}
+          ocr config set llm.model ${{ secrets.OCR_LLM_MODEL }}
+          ocr config set llm.use_anthropic ${{ secrets.OCR_LLM_USE_ANTHROPIC }}
+          ocr config set llm.extra_body '{"thinking": {"type": "disabled"}}'
+
+      - name: Run OpenCodeReview
+        id: review
+        run: |
+          # Get base and head refs from PR context (different for comment triggers)
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            BASE_REF="${{ github.event.pull_request.base.ref }}"
+            HEAD_REF="${{ github.event.pull_request.head.ref }}"
+          else
+            BASE_REF="${{ steps.pr-context.outputs.base_ref }}"
+            HEAD_REF="${{ steps.pr-context.outputs.head_ref }}"
+          fi
+
+          echo "Reviewing PR: ${HEAD_REF} against ${BASE_REF}"
+
+          # Run OCR in range mode with JSON output
+          ocr review \
+            --from "origin/${BASE_REF}" \
+            --to "origin/${HEAD_REF}" \
+            --format json \
+            --audience agent \
+            > /tmp/ocr-result.json 2>/tmp/ocr-stderr.log || true
+
+          echo "OCR review completed. Output:"
+          cat /tmp/ocr-result.json
+          echo "OCR review completed. Error log:"
+          cat /tmp/ocr-stderr.log
+
+      - name: Post review comments to PR
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const fs = require('fs');
+            const path = '/tmp/ocr-result.json';
+
+            // Read OCR output (skip first line which is not valid JSON)
+            let result;
+            try {
+              const raw = fs.readFileSync(path, 'utf8');
+              const jsonContent = raw.substring(raw.indexOf('\n') + 1);
+              result = JSON.parse(jsonContent);
+            } catch (e) {
+              console.log('Failed to parse OCR output:', e.message);
+              // Post a simple comment if parsing fails
+              const stderr = fs.readFileSync('/tmp/ocr-stderr.log', 'utf8').trim();
+              if (stderr) {
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  body: `⚠️ **OpenCodeReview** encountered an error:\n\`\`\`\n${stderr}\n\`\`\``
+                });
+              }
+              return;
+            }
+
+            const comments = result.comments || [];
+            const warnings = result.warnings || [];
+
+            // If no comments, post a summary
+            if (comments.length === 0) {
+              const message = result.message || 'No comments generated. Looks good to me.';
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body: `✅ **OpenCodeReview**: ${message}`
+              });
+              return;
+            }
+
+            // Prepare PR review with inline comments
+            const prNumber = context.issue.number;
+            let commitSha;
+            
+            // Get commit SHA from event context
+            if (context.eventName === 'pull_request') {
+              commitSha = context.payload.pull_request.head.sha;
+            } else {
+              // For comment events, we need to fetch the PR
+              const { data: pullRequest } = await github.rest.pulls.get({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                pull_number: prNumber
+              });
+              commitSha = pullRequest.head.sha;
+            }
+
+            // Build review comments array for the PR review API
+            // Only inline comments with line info can be posted via createReview
+            const reviewComments = [];
+            const commentsWithoutLine = [];
+
+            for (const comment of comments) {
+              const body = formatComment(comment);
+
+              // Check if comment has valid line information for inline comment (line >= 1)
+              const hasValidLine = (comment.start_line >= 1) || (comment.end_line >= 1);
+              if (!hasValidLine) {
+                commentsWithoutLine.push({ comment, body });
+                continue;
+              }
+
+              const reviewComment = {
+                path: comment.path,
+                body: body
+              };
+
+              // Use line range if available
+              if (comment.start_line >= 1 && comment.end_line >= 1 && comment.start_line !== comment.end_line) {
+                reviewComment.start_line = comment.start_line;
+                reviewComment.line = comment.end_line;
+                reviewComment.start_side = 'RIGHT';
+                reviewComment.side = 'RIGHT';
+              } else if (comment.end_line >= 1) {
+                reviewComment.line = comment.end_line;
+                reviewComment.side = 'RIGHT';
+              } else if (comment.start_line >= 1) {
+                reviewComment.line = comment.start_line;
+                reviewComment.side = 'RIGHT';
+              }
+
+              reviewComments.push(reviewComment);
+            }
+
+            // Submit as a single PR review with all comments
+            const totalCount = comments.length;
+            const inlineCount = reviewComments.length;
+            const summaryCount = commentsWithoutLine.length;
+            let summaryBody = `🔍 **OpenCodeReview** found **${totalCount}** issue(s) in this PR.`;
+            if (totalCount > 0) {
+              summaryBody += `\n- ✅ ${inlineCount} posted as inline comment(s)`;
+              summaryBody += `\n- 📝 ${summaryCount} posted as summary (missing line info)`;
+            }
+            if (warnings.length > 0) {
+              summaryBody += `\n\n⚠️ ${warnings.length} warning(s) occurred during review.`;
+            }
+
+            // Add comments without line info to summary body
+            for (const { comment, body } of commentsWithoutLine) {
+              summaryBody += '\n\n---\n\n';
+              summaryBody += formatCommentMarkdown(comment);
+            }
+
+            // Statistics tracking
+            let successCount = 0;
+            let failedCount = 0;
+            const failedComments = [];
+
+            try {
+              await github.rest.pulls.createReview({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                pull_number: prNumber,
+                commit_id: commitSha,
+                body: summaryBody,
+                event: 'COMMENT',
+                comments: reviewComments
+              });
+              successCount = reviewComments.length;
+              console.log(`Successfully posted review with ${successCount} inline comments (${commentsWithoutLine.length} in summary)`);
+            } catch (e) {
+              console.log('Failed to post review with inline comments:', e.message);
+              console.log('Falling back to posting comments individually...');
+              
+              // Fallback: post comments one by one
+              for (const reviewComment of reviewComments) {
+                try {
+                  await github.rest.pulls.createReview({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    pull_number: prNumber,
+                    commit_id: commitSha,
+                    body: '',
+                    event: 'COMMENT',
+                    comments: [reviewComment]
+                  });
+                  successCount++;
+                  console.log(`Successfully posted comment for ${reviewComment.path}`);
+                } catch (innerE) {
+                  failedCount++;
+                  failedComments.push({ comment: reviewComment, error: innerE.message });
+                  console.log(`Failed to post comment for ${reviewComment.path}: ${innerE.message}`);
+                }
+              }
+              
+              // Post summary comment with statistics
+              let finalBody = summaryBody;
+              finalBody += `\n\n---\n\n📊 **Posting Statistics:**`;
+              finalBody += `\n- ✅ Successfully posted: ${successCount} comment(s)`;
+              if (failedCount > 0) {
+                finalBody += `\n- ❌ Failed to post: ${failedCount} comment(s)`;
+              }
+              
+              // Add failed comments details
+              if (failedComments.length > 0) {
+                finalBody += '\n\n<details><summary>❌ Failed Comments Details</summary>\n\n';
+                for (const { comment, error } of failedComments) {
+                  finalBody += `- \`${comment.path}\`: ${error}\n`;
+                }
+                finalBody += '\n</details>';
+              }
+              
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: prNumber,
+                body: finalBody
+              });
+            }
+
+            function formatComment(comment) {
+              let body = comment.content || '';
+
+              // Add code suggestion if available
+              if (comment.suggestion_code && comment.existing_code) {
+                body += '\n\n**Suggestion:**\n';
+                body += '```suggestion\n';
+                body += comment.suggestion_code;
+                if (!comment.suggestion_code.endsWith('\n')) body += '\n';
+                body += '```';
+              }
+
+              return body;
+            }
+
+            function formatCommentMarkdown(comment) {
+              let md = `### 📄 \`${comment.path}\``;
+              if (comment.start_line && comment.end_line) {
+                md += ` (L${comment.start_line}-L${comment.end_line})`;
+              }
+              md += '\n\n';
+              md += comment.content || '';
+
+              if (comment.suggestion_code && comment.existing_code) {
+                md += '\n\n<details><summary>💡 Suggested Change</summary>\n\n';
+                md += '**Before:**\n```\n' + comment.existing_code + '\n```\n\n';
+                md += '**After:**\n```\n' + comment.suggestion_code + '\n```\n\n';
+                md += '</details>';
+              }
+
+              return md;
+            }

package/examples/gitlab_ci/.gitlab-ci.yml

@@ -0,0 +1,225 @@
+# OpenCodeReview - GitLab CI Merge Request Auto-Review Demo
+#
+# This pipeline automatically reviews Merge Requests using OpenCodeReview
+# and posts review comments (discussions) directly on the MR diff.
+#
+# Required CI/CD Variables (Settings → CI/CD → Variables):
+#   OCR_LLM_URL        - LLM API endpoint (e.g., https://api.openai.com/v1/chat/completions)
+#   OCR_LLM_AUTH_TOKEN - Authentication token for the LLM API (mark as "Masked")
+#   GITLAB_API_TOKEN   - GitLab Personal/Project Access Token with "api" scope
+#
+# Optional CI/CD Variables:
+#   OCR_LLM_MODEL      - Model name (default: gpt-4o)
+
+stages:
+  - review
+
+code-review:
+  stage: review
+  image: node:20
+  only:
+    - merge_requests
+  variables:
+    GIT_DEPTH: 0  # Full history needed for merge-base diff
+  script:
+    # Install OpenCodeReview
+    - npm install -g @alibaba-group/open-code-review
+
+    # Configure OCR
+    - mkdir -p ~/.open-code-review
+    # Gitlab CI/CD does not support confuring variables with value length less than 8, so you can't set use_anthropic as a CI variable
+    - |
+      ocr config set llm.url $OCR_LLM_URL
+      ocr config set llm.auth_token $OCR_LLM_AUTH_TOKEN
+      ocr config set llm.model $OCR_LLM_MODEL
+      ocr config set llm.use_anthropic false
+      ocr config set llm.extra_body '{"thinking": {"type": "disabled"}}'
+
+    # Run OCR review
+    - |
+      echo "Reviewing MR: ${CI_MERGE_REQUEST_SOURCE_BRANCH_NAME} against ${CI_MERGE_REQUEST_TARGET_BRANCH_NAME}"
+      ocr review \
+        --from "origin/${CI_MERGE_REQUEST_TARGET_BRANCH_NAME}" \
+        --to "origin/${CI_MERGE_REQUEST_SOURCE_BRANCH_NAME}" \
+        --format json \
+        --audience agent \
+        > /tmp/ocr-result.json 2>/tmp/ocr-stderr.log || true
+      echo "OCR review completed."
+      cat /tmp/ocr-result.json
+
+    # Post review comments to MR
+    - |
+      python3 << 'PYTHON_SCRIPT'
+      import json
+      import os
+      import sys
+      import urllib.request
+      import urllib.error
+
+      GITLAB_URL = os.environ.get("CI_SERVER_URL", "https://gitlab.com")
+      PROJECT_ID = os.environ["CI_PROJECT_ID"]
+      MR_IID = os.environ["CI_MERGE_REQUEST_IID"]
+      API_TOKEN = os.environ["GITLAB_API_TOKEN"]
+      SOURCE_BRANCH = os.environ["CI_MERGE_REQUEST_SOURCE_BRANCH_NAME"]
+      TARGET_BRANCH = os.environ["CI_MERGE_REQUEST_TARGET_BRANCH_NAME"]
+      COMMIT_SHA = os.environ["CI_COMMIT_SHA"]
+
+      API_BASE = f"{GITLAB_URL}/api/v4/projects/{PROJECT_ID}/merge_requests/{MR_IID}"
+
+      def api_request(endpoint, data=None, method="POST"):
+          """Make a GitLab API request."""
+          url = f"{API_BASE}{endpoint}"
+          headers = {
+              "PRIVATE-TOKEN": API_TOKEN,
+              "Content-Type": "application/json"
+          }
+          body = json.dumps(data).encode("utf-8") if data else None
+          req = urllib.request.Request(url, data=body, headers=headers, method=method)
+          try:
+              with urllib.request.urlopen(req) as resp:
+                  return json.loads(resp.read().decode("utf-8"))
+          except urllib.error.HTTPError as e:
+              print(f"API error {e.code}: {e.read().decode('utf-8')}", file=sys.stderr)
+              return None
+
+      def post_note(body):
+          """Post a general note/comment on the MR."""
+          return api_request("/notes", {"body": body})
+
+      def post_discussion(path, line, body, base_sha=None, start_sha=None, head_sha=None):
+          """Post an inline discussion on a specific file/line in the MR diff."""
+          position = {
+              "position_type": "text",
+              "new_path": path,
+              "old_path": path,
+              "new_line": line,
+              "base_sha": base_sha or TARGET_BRANCH,
+              "start_sha": start_sha or TARGET_BRANCH,
+              "head_sha": head_sha or COMMIT_SHA,
+          }
+          data = {
+              "body": body,
+              "position": position
+          }
+          return api_request("/discussions", data)
+
+      def format_comment(comment):
+          """Format a single review comment as markdown."""
+          body = comment.get("content", "")
+
+          existing = comment.get("existing_code", "")
+          suggestion = comment.get("suggestion_code", "")
+          if suggestion and existing:
+              body += "\n\n**Suggestion:**\n"
+              body += f"```suggestion:-0+0\n{suggestion}\n```"
+
+          return body
+
+      def format_comment_fallback(comment):
+          """Format a comment for fallback (non-inline) display."""
+          path = comment.get("path", "unknown")
+          start_line = comment.get("start_line", 0)
+          end_line = comment.get("end_line", 0)
+          content = comment.get("content", "")
+
+          md = f"### 📄 `{path}`"
+          if start_line and end_line:
+              md += f" (L{start_line}-L{end_line})"
+          md += f"\n\n{content}"
+
+          existing = comment.get("existing_code", "")
+          suggestion = comment.get("suggestion_code", "")
+          if suggestion and existing:
+              md += "\n\n<details><summary>💡 Suggested Change</summary>\n\n"
+              md += f"**Before:**\n```\n{existing}\n```\n\n"
+              md += f"**After:**\n```\n{suggestion}\n```\n\n"
+              md += "</details>"
+
+          return md
+
+      # --- Main ---
+
+      # Read OCR result (skip first line which is summary, not JSON)
+      try:
+          with open("/tmp/ocr-result.json", "r") as f:
+              next(f)  # Skip first line
+              result = json.load(f)
+      except (FileNotFoundError, json.JSONDecodeError) as e:
+          print(f"Failed to parse OCR output: {e}", file=sys.stderr)
+          stderr_content = ""
+          try:
+              with open("/tmp/ocr-stderr.log", "r") as f:
+                  stderr_content = f.read().strip()
+          except FileNotFoundError:
+              pass
+          if stderr_content:
+              post_note(f"⚠️ **OpenCodeReview** encountered an error:\n```\n{stderr_content}\n```")
+          sys.exit(0)
+
+      comments = result.get("comments", [])
+      warnings = result.get("warnings", [])
+
+      # No comments - post summary
+      if not comments:
+          message = result.get("message", "No comments generated. Looks good to me.")
+          post_note(f"✅ **OpenCodeReview**: {message}")
+          print("No review comments to post.")
+          sys.exit(0)
+
+      # Get MR diff metadata for position calculation
+      diff_refs = None
+      try:
+          versions_url = f"{API_BASE}/versions"
+          req = urllib.request.Request(versions_url, headers={"PRIVATE-TOKEN": API_TOKEN})
+          with urllib.request.urlopen(req) as resp:
+              versions = json.loads(resp.read().decode("utf-8"))
+          if versions:
+              latest = versions[0]
+              diff_refs = {
+                  "base_sha": latest.get("base_commit_sha", ""),
+                  "start_sha": latest.get("start_commit_sha", ""),
+                  "head_sha": latest.get("head_commit_sha", ""),
+              }
+      except Exception as e:
+          print(f"Warning: Could not fetch MR versions: {e}", file=sys.stderr)
+
+      # Post inline discussions for each comment
+      success_count = 0
+      failed_comments = []
+
+      for comment in comments:
+          path = comment.get("path", "")
+          end_line = comment.get("end_line", 0)
+          start_line = comment.get("start_line", end_line)
+          body = format_comment(comment)
+
+          if not path or not end_line:
+              failed_comments.append(comment)
+              continue
+
+          kwargs = {}
+          if diff_refs:
+              kwargs = diff_refs
+
+          result_resp = post_discussion(path, end_line, body, **kwargs)
+          if result_resp:
+              success_count += 1
+          else:
+              failed_comments.append(comment)
+
+      print(f"Successfully posted {success_count}/{len(comments)} inline comments.")
+
+      # Post fallback for any failed inline comments
+      if failed_comments:
+          fallback_body = f"🔍 **OpenCodeReview** found issues that could not be posted inline:\n\n---\n\n"
+          for comment in failed_comments:
+              fallback_body += format_comment_fallback(comment) + "\n\n---\n\n"
+          post_note(fallback_body)
+
+      # Post summary
+      summary = f"🔍 **OpenCodeReview** found **{len(comments)}** issue(s) in this MR."
+      if warnings:
+          summary += f"\n\n⚠️ {len(warnings)} warning(s) occurred during review."
+      post_note(summary)
+
+      PYTHON_SCRIPT