ultralytics-actions 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

actions/review_pr.py

@@ -5,10 +5,28 @@ from __future__ import annotations
 import json
 import re
 
-from .utils import GITHUB_API_URL, Action, get_completion
+from .utils import GITHUB_API_URL, Action, get_completion, remove_html_comments
 
 REVIEW_MARKER = "🔍 PR Review"
 EMOJI_MAP = {"CRITICAL": "❗", "HIGH": "⚠️", "MEDIUM": "💡", "LOW": "📝", "SUGGESTION": "💭"}
+SKIP_PATTERNS = [
+    r"\.lock$",  # Lock files
+    r"-lock\.(json|yaml|yml)$",
+    r"\.min\.(js|css)$",  # Minified
+    r"\.bundle\.(js|css)$",
+    r"(^|/)dist/",  # Generated/vendored directories
+    r"(^|/)build/",
+    r"(^|/)vendor/",
+    r"(^|/)node_modules/",
+    r"\.pb\.py$",  # Proto generated
+    r"_pb2\.py$",
+    r"_pb2_grpc\.py$",
+    r"^package-lock\.json$",  # Package locks
+    r"^yarn\.lock$",
+    r"^poetry\.lock$",
+    r"^Pipfile\.lock$",
+    r"\.(svg|png|jpe?g|gif)$",  # Images
+]
 
 
 def parse_diff_files(diff_text: str) -> dict:
@@ -37,44 +55,65 @@ def parse_diff_files(diff_text: str) -> dict:
 
 def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_description: str) -> dict:
     """Generate comprehensive PR review with line-specific comments and overall assessment."""
-    if not diff_text or "**ERROR" in diff_text:
-        return {"comments": [], "summary": f"Unable to review: {diff_text if '**ERROR' in diff_text else 'diff empty'}"}
+    if not diff_text:
+        return {"comments": [], "summary": "No changes detected in diff"}
 
     diff_files = parse_diff_files(diff_text)
     if not diff_files:
         return {"comments": [], "summary": "No files with changes detected in diff"}
 
+    # Filter out generated/vendored files
+    filtered_files = {
+        path: lines
+        for path, lines in diff_files.items()
+        if not any(re.search(pattern, path) for pattern in SKIP_PATTERNS)
+    }
+    skipped_count = len(diff_files) - len(filtered_files)
+    diff_files = filtered_files
+
+    if not diff_files:
+        return {"comments": [], "summary": f"All {skipped_count} changed files are generated/vendored (skipped review)"}
+
     file_list = list(diff_files.keys())
-    limit = round(128000 * 3.3 * 0.4)
+    limit = round(128000 * 3.3 * 0.5)  # 3.3 characters per token for half a 256k context window
     diff_truncated = len(diff_text) > limit
     lines_changed = sum(len(lines) for lines in diff_files.values())
 
-    valid_lines_text = "\n".join(
-        f"  {file}: {sorted(list(lines.keys())[:20])}{' ...' if len(lines) > 20 else ''}"
-        for file, lines in list(diff_files.items())[:10]
-    ) + ("\n  ..." if len(diff_files) > 10 else "")
-
-    priority_guidance = (
-        "Prioritize the most critical/high-impact issues only"
-        if lines_changed >= 100
-        else "Prioritize commenting on different files/sections"
+    comment_guidance = (
+        "Provide up to 1-3 comments only if critical issues exist"
+        if lines_changed < 50
+        else "Provide up to 3-5 comments only if high-impact issues exist"
+        if lines_changed < 200
+        else "Provide up to 5-10 comments only for the most critical issues"
     )
 
     content = (
         "You are an expert code reviewer for Ultralytics. Provide detailed inline comments on specific code changes.\n\n"
         "Focus on: Code quality, style, best practices, bugs, edge cases, error handling, performance, security, documentation, test coverage\n\n"
-        "FORMATTING: Use backticks for code, file names, branch names, function names, variable names, packages\n\n"
+        "FORMATTING: Use backticks for all summary and suggestion code, files, branches, functions, variables, packages, e.g. `x=3`\n\n"
         "CRITICAL RULES:\n"
-        f"1. Generate inline comments with recommended changes for clear bugs/security/syntax issues (up to 10)\n"
-        "2. Each comment MUST reference a UNIQUE line number(s)\n"
-        "3. If a section has multiple issues, combine ALL issues into ONE comment for that section\n"
-        "4. Never create separate comments for the same line number(s)\n"
-        f"5. {priority_guidance}\n\n"
+        "1. Quality over quantity: Zero comments is fine for clean code - only flag truly important issues\n"
+        f"2. {comment_guidance} - these are maximums, not targets\n"
+        "3. CRITICAL: Do not post separate comments on adjacent/nearby lines (within 10 lines). Combine all related issues into ONE comment\n"
+        "4. When combining issues from multiple lines, use 'start_line' (first line) and 'line' (last line) to highlight the entire range\n"
+        "5. Each comment must reference separate areas - no overlapping line ranges\n"
+        "6. Prioritize: CRITICAL bugs/security > HIGH impact issues > code quality\n"
+        "7. Keep comments concise, friendly, and easy to understand - avoid jargon when possible\n"
+        "8. DO not comment on routine changes: adding imports, adding dependencies, updating version numbers, standard refactoring\n"
+        "9. Trust the developer - only flag issues with clear evidence of problems, not hypothetical concerns\n\n"
+        "SUMMARY GUIDELINES:\n"
+        "- Keep summary brief, clear, and actionable - avoid overly detailed explanations\n"
+        "- Highlight only the most important findings\n"
+        "- Do NOT include file names or line numbers in the summary - inline comments already show exact locations\n"
+        "- Focus on what needs to be fixed, not where\n\n"
         "CODE SUGGESTIONS:\n"
         "- ONLY provide 'suggestion' field when you have high certainty the code is problematic AND sufficient context for a confident fix\n"
         "- If uncertain about the correct fix, omit 'suggestion' field and explain the concern in 'message' only\n"
         "- Suggestions must be ready-to-merge code with NO comments, placeholders, or explanations\n"
-        "- When providing suggestions, ensure they are complete, correct, and maintain existing indentation\n"
+        "- Suggestions replace ONLY the single line at 'line' - for multi-line fixes, describe the change in 'message' instead\n"
+        "- Do NOT provide 'start_line' when including a 'suggestion' - suggestions are always single-line only\n"
+        "- Suggestion content must match the exact indentation of the original line\n"
+        "- Avoid triple backticks (```) in suggestions as they break markdown formatting\n"
         "- It's better to flag an issue without a suggestion than provide a wrong or uncertain fix\n\n"
         "Return JSON: "
         '{"comments": [{"file": "exact/path", "line": N, "severity": "HIGH", "message": "...", "suggestion": "..."}], "summary": "..."}\n\n'
@@ -85,16 +124,20 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
         "- When '- old' then '+ new', new line keeps SAME line number\n"
         "- Severity: CRITICAL, HIGH, MEDIUM, LOW, SUGGESTION\n"
         f"- Files changed: {len(file_list)} ({', '.join(file_list[:10])}{'...' if len(file_list) > 10 else ''})\n"
-        f"- Total changed lines: {lines_changed}\n"
-        f"- Diff {'truncated' if diff_truncated else 'complete'}: {len(diff_text[:limit])} chars{f' of {len(diff_text)}' if diff_truncated else ''}\n\n"
-        f"VALID LINE NUMBERS (use ONLY these):\n{valid_lines_text}"
+        f"- Lines changed: {lines_changed}\n"
     )
 
     messages = [
         {"role": "system", "content": content},
         {
             "role": "user",
-            "content": f"Review PR '{repository}':\nTitle: {pr_title}\nDescription: {pr_description[:500]}\n\nDiff:\n{diff_text[:limit]}",
+            "content": (
+                f"Review this PR in https://github.com/{repository}:\n"
+                f"Title: {pr_title}\n"
+                f"Description: {remove_html_comments(pr_description or '')[:1000]}\n\n"
+                f"Diff:\n{diff_text[:limit]}\n\n"
+                "Now review this diff according to the rules above. Return JSON with comments array and summary."
+            ),
         },
     ]
 
@@ -111,23 +154,45 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
         unique_comments = {}
         for c in review_data.get("comments", []):
             file_path, line_num = c.get("file"), c.get("line", 0)
-            if file_path in diff_files and line_num in diff_files[file_path]:
-                key = f"{file_path}:{line_num}"
-                if key not in unique_comments:
-                    unique_comments[key] = c
-                else:
-                    print(f"⚠️  AI duplicate for {key}: {c.get('severity')} - {c.get('message')[:60]}...")
-            else:
+            start_line = c.get("start_line")
+
+            # Validate line numbers are in diff
+            if file_path not in diff_files or line_num not in diff_files[file_path]:
                 print(f"Filtered out {file_path}:{line_num} (available: {list(diff_files.get(file_path, {}))[:10]}...)")
+                continue
+
+            # Validate start_line if provided - drop start_line for suggestions (single-line only)
+            if start_line:
+                if c.get("suggestion"):
+                    print(f"Dropping start_line for {file_path}:{line_num} - suggestions must be single-line only")
+                    c.pop("start_line", None)
+                elif start_line >= line_num:
+                    print(f"Invalid start_line {start_line} >= line {line_num} for {file_path}, dropping start_line")
+                    c.pop("start_line", None)
+                elif start_line not in diff_files[file_path]:
+                    print(f"start_line {start_line} not in diff for {file_path}, dropping start_line")
+                    c.pop("start_line", None)
+
+            # Deduplicate by line number
+            key = f"{file_path}:{line_num}"
+            if key not in unique_comments:
+                unique_comments[key] = c
+            else:
+                print(f"⚠️  AI duplicate for {key}: {c.get('severity')} - {c.get('message')[:60]}...")
 
         review_data.update(
-            {"comments": list(unique_comments.values()), "diff_files": diff_files, "diff_truncated": diff_truncated}
+            {
+                "comments": list(unique_comments.values()),
+                "diff_files": diff_files,
+                "diff_truncated": diff_truncated,
+                "skipped_files": skipped_count,
+            }
         )
         print(f"Valid comments after filtering: {len(review_data['comments'])}")
         return review_data
 
     except json.JSONDecodeError as e:
-        print(f"JSON parsing failed: {e}\nAttempted: {json_str[:500] if 'json_str' in locals() else response[:500]}...")
+        print(f"JSON parsing failed... {e}")
         return {"comments": [], "summary": "Review generation encountered a JSON parsing error"}
     except Exception as e:
         print(f"Review generation failed: {e}")
@@ -164,39 +229,14 @@ def dismiss_previous_reviews(event: Action) -> int:
     return review_count + 1
 
 
-def post_review_comments(event: Action, review_data: dict) -> None:
-    """Post inline review comments on specific lines of the PR."""
-    if not (pr_number := event.pr.get("number")) or not (commit_sha := event.pr.get("head", {}).get("sha")):
-        return
-
-    url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{pr_number}/comments"
-    diff_files = review_data.get("diff_files", {})
-
-    for comment in review_data.get("comments", [])[:50]:
-        if not (file_path := comment.get("file")) or not (line := comment.get("line", 0)):
-            continue
-
-        severity = comment.get("severity", "SUGGESTION")
-        body = f"{EMOJI_MAP.get(severity, '💭')} **{severity}**: {comment.get('message', '')}"
-
-        if suggestion := comment.get("suggestion"):
-            original_line = diff_files.get(file_path, {}).get(line, "")
-            indent = len(original_line) - len(original_line.lstrip())
-            indented = "\n".join(" " * indent + l if l.strip() else l for l in suggestion.split("\n"))
-            body += f"\n\n**Suggested change:**\n```suggestion\n{indented}\n```"
-
-        event.post(url, json={"body": body, "commit_id": commit_sha, "path": file_path, "line": line, "side": "RIGHT"})
-
-
 def post_review_summary(event: Action, review_data: dict, review_number: int) -> None:
-    """Post overall review summary as a PR review."""
+    """Post overall review summary and inline comments as a single PR review."""
     if not (pr_number := event.pr.get("number")) or not (commit_sha := event.pr.get("head", {}).get("sha")):
         return
 
     review_title = f"{REVIEW_MARKER} {review_number}" if review_number > 1 else REVIEW_MARKER
     comments = review_data.get("comments", [])
-    max_severity = max((c.get("severity") for c in comments), default="SUGGESTION") if comments else None
-    event_type = "APPROVE" if not comments or max_severity in ["LOW", "SUGGESTION"] else "REQUEST_CHANGES"
+    event_type = "COMMENT" if any(c.get("severity") not in ["LOW", "SUGGESTION", None] for c in comments) else "APPROVE"
 
     body = (
         f"## {review_title}\n\n"
@@ -205,15 +245,51 @@ def post_review_summary(event: Action, review_data: dict, review_number: int) ->
     )
 
     if comments:
-        shown = min(len(comments), 50)
-        body += f"💬 Posted {shown} inline comment{'s' if shown != 1 else ''}{' (50 shown, more available)' if len(comments) > 50 else ''}\n"
+        shown = min(len(comments), 10)
+        body += f"💬 Posted {shown} inline comment{'s' if shown != 1 else ''}{' (10 shown, more available)' if len(comments) > 10 else ''}\n"
 
     if review_data.get("diff_truncated"):
         body += "\n⚠️ **Large PR**: Review focused on critical issues. Some details may not be covered.\n"
 
+    if skipped := review_data.get("skipped_files"):
+        body += f"\n📋 **Skipped {skipped} file{'s' if skipped != 1 else ''}** (lock files, minified, images, etc.)\n"
+
+    # Build inline comments for the review
+    review_comments = []
+    for comment in comments[:10]:
+        if not (file_path := comment.get("file")) or not (line := comment.get("line", 0)):
+            continue
+
+        severity = comment.get("severity", "SUGGESTION")
+        comment_body = f"{EMOJI_MAP.get(severity, '💭')} **{severity}**: {comment.get('message', '')}"
+
+        if suggestion := comment.get("suggestion"):
+            if "```" not in suggestion:
+                # Extract original line indentation and apply to suggestion
+                if original_line := review_data.get("diff_files", {}).get(file_path, {}).get(line):
+                    indent = len(original_line) - len(original_line.lstrip())
+                    suggestion = " " * indent + suggestion.strip()
+                comment_body += f"\n\n**Suggested change:**\n```suggestion\n{suggestion}\n```"
+
+        # Build comment with optional start_line for multi-line context
+        review_comment = {"path": file_path, "line": line, "body": comment_body, "side": "RIGHT"}
+        if start_line := comment.get("start_line"):
+            if start_line < line:
+                review_comment["start_line"] = start_line
+                review_comment["start_side"] = "RIGHT"
+                print(f"Multi-line comment: {file_path}:{start_line}-{line}")
+
+        review_comments.append(review_comment)
+
+    # Submit review with inline comments
+    payload = {"commit_id": commit_sha, "body": body, "event": event_type}
+    if review_comments:
+        payload["comments"] = review_comments
+        print(f"Posting review with {len(review_comments)} inline comments")
+
     event.post(
         f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{pr_number}/reviews",
-        json={"commit_id": commit_sha, "body": body, "event": event_type},
+        json=payload,
     )
 
 
@@ -235,11 +311,10 @@ def main(*args, **kwargs):
     review_number = dismiss_previous_reviews(event)
 
     diff = event.get_pr_diff()
-    review = generate_pr_review(event.repository, diff, event.pr.get("title", ""), event.pr.get("body", ""))
+    pr_description = event._pr_summary_cache or event.pr.get("body", "")
+    review = generate_pr_review(event.repository, diff, event.pr.get("title", ""), pr_description)
 
     post_review_summary(event, review, review_number)
-    print(f"Posting {len(review.get('comments', []))} inline comments")
-    post_review_comments(event, review)
     print("PR review completed")
 
 

actions/summarize_pr.py

@@ -2,17 +2,14 @@
 
 from __future__ import annotations
 
-import time
+from .utils import GITHUB_API_URL, Action, get_completion, get_pr_summary_prompt
 
-from .utils import GITHUB_API_URL, GITHUB_GRAPHQL_URL, Action, get_completion
-
-# Constants
 SUMMARY_START = (
     "## 🛠️ PR Summary\n\n<sub>Made with ❤️ by [Ultralytics Actions](https://github.com/ultralytics/actions)<sub>\n\n"
 )
 
 
-def generate_merge_message(pr_summary=None, pr_credit=None, pr_url=None):
+def generate_merge_message(pr_summary, pr_credit, pr_url):
     """Generates a motivating thank-you message for merged PR contributors."""
     messages = [
         {
@@ -32,17 +29,8 @@ def generate_merge_message(pr_summary=None, pr_credit=None, pr_url=None):
     return get_completion(messages)
 
 
-def post_merge_message(event, summary, pr_credit):
-    """Posts thank you message on PR after merge."""
-    pr_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{event.pr['number']}"
-    comment_url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{event.pr['number']}/comments"
-    message = generate_merge_message(summary, pr_credit, pr_url)
-    event.post(comment_url, json={"body": message})
-
-
 def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
     """Generates personalized issue comment based on PR context."""
-    # Extract repo info from PR URL (format: api.github.com/repos/owner/repo/pulls/number)
     repo_parts = pr_url.split("/repos/")[1].split("/pulls/")[0] if "/repos/" in pr_url else ""
     owner_repo = repo_parts.split("/")
     repo_name = owner_repo[-1] if len(owner_repo) > 1 else "package"
@@ -72,137 +60,47 @@ def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
 
 
 def generate_pr_summary(repository, diff_text):
-    """Generates a concise, professional summary of a PR using OpenAI's API for Ultralytics repositories."""
-    if not diff_text:
-        diff_text = "**ERROR: DIFF IS EMPTY, THERE ARE ZERO CODE CHANGES IN THIS PR."
-    ratio = 3.3  # about 3.3 characters per token
-    limit = round(128000 * ratio * 0.5)  # use up to 50% of the 128k context window for prompt
+    """Generates a concise, professional summary of a PR using OpenAI's API."""
+    prompt, is_large = get_pr_summary_prompt(repository, diff_text)
+
     messages = [
         {
             "role": "system",
             "content": "You are an Ultralytics AI assistant skilled in software development and technical communication. Your task is to summarize GitHub PRs from Ultralytics in a way that is accurate, concise, and understandable to both expert developers and non-expert users. Focus on highlighting the key changes and their impact in simple, concise terms.",
         },
-        {
-            "role": "user",
-            "content": f"Summarize this '{repository}' PR, focusing on major changes, their purpose, and potential impact. Keep the summary clear and concise, suitable for a broad audience. Add emojis to enliven the summary. Reply directly with a summary along these example guidelines, though feel free to adjust as appropriate:\n\n"
-            f"### 🌟 Summary (single-line synopsis)\n"
-            f"### 📊 Key Changes (bullet points highlighting any major changes)\n"
-            f"### 🎯 Purpose & Impact (bullet points explaining any benefits and potential impact to users)\n"
-            f"\n\nHere's the PR diff:\n\n{diff_text[:limit]}",
-        },
+        {"role": "user", "content": prompt},
     ]
     reply = get_completion(messages, temperature=1.0)
-    if len(diff_text) > limit:
+    if is_large:
         reply = "**WARNING ⚠️** this PR is very large, summary may not cover all changes.\n\n" + reply
     return SUMMARY_START + reply
 
 
-def update_pr_description(event, new_summary, max_retries=2):
-    """Updates PR description with new summary, retrying if description is None."""
-    description = ""
-    url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{event.pr['number']}"
-    for i in range(max_retries + 1):
-        description = event.get(url).json().get("body") or ""
-        if description:
-            break
-        if i < max_retries:
-            print("No current PR description found, retrying...")
-            time.sleep(1)
-
-    # Check if existing summary is present and update accordingly
-    start = "## 🛠️ PR Summary"
-    if start in description:
-        print("Existing PR Summary found, replacing.")
-        updated_description = description.split(start)[0] + new_summary
-    else:
-        print("PR Summary not found, appending.")
-        updated_description = description + "\n\n" + new_summary
-
-    # Update the PR description
-    event.patch(url, json={"body": updated_description})
-
-
 def label_fixed_issues(event, pr_summary):
     """Labels issues closed by PR when merged, notifies users, and returns PR contributors."""
-    query = """
-query($owner: String!, $repo: String!, $pr_number: Int!) {
-    repository(owner: $owner, name: $repo) {
-        pullRequest(number: $pr_number) {
-            closingIssuesReferences(first: 50) { nodes { number } }
-            url
-            title
-            body
-            author { login, __typename }
-            reviews(first: 50) { nodes { author { login, __typename } } }
-            comments(first: 50) { nodes { author { login, __typename } } }
-            commits(first: 100) { nodes { commit { author { user { login } }, committer { user { login } } } } }
-        }
-    }
-}
-"""
-    owner, repo = event.repository.split("/")
-    variables = {"owner": owner, "repo": repo, "pr_number": event.pr["number"]}
-    response = event.post(GITHUB_GRAPHQL_URL, json={"query": query, "variables": variables})
-    if response.status_code != 200:
-        return None  # no linked issues
-
-    try:
-        data = response.json()["data"]["repository"]["pullRequest"]
-        comments = data["reviews"]["nodes"] + data["comments"]["nodes"]
-        token_username = event.get_username()  # get GITHUB_TOKEN username
-        author = data["author"]["login"] if data["author"]["__typename"] != "Bot" else None
-        pr_title = data.get("title", "")
-
-        # Get unique contributors from reviews and comments
-        contributors = {x["author"]["login"] for x in comments if x["author"]["__typename"] != "Bot"}
-
-        # Add commit authors and committers that have GitHub accounts linked
-        for commit in data["commits"]["nodes"]:
-            commit_data = commit["commit"]
-            for user_type in ["author", "committer"]:
-                if user := commit_data[user_type].get("user"):
-                    if login := user.get("login"):
-                        contributors.add(login)
-
-        contributors.discard(author)
-        contributors.discard(token_username)
-
-        # Write credit string
-        pr_credit = ""  # i.e. "@user1 with contributions from @user2, @user3"
-        if author and author != token_username:
-            pr_credit += f"@{author}"
-        if contributors:
-            pr_credit += (" with contributions from " if pr_credit else "") + ", ".join(f"@{c}" for c in contributors)
-
-        # Generate personalized comment
-        comment = generate_issue_comment(
-            pr_url=data["url"], pr_summary=pr_summary, pr_credit=pr_credit, pr_title=pr_title
-        )
-
-        # Update linked issues
-        for issue in data["closingIssuesReferences"]["nodes"]:
-            number = issue["number"]
-            # Add fixed label
-            event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/labels", json={"labels": ["fixed"]})
-
-            # Add comment
-            event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/comments", json={"body": comment})
-
-        return pr_credit
-    except KeyError as e:
-        print(f"Error parsing GraphQL response: {e}")
+    pr_credit, data = event.get_pr_contributors()
+    if not pr_credit:
         return None
 
+    comment = generate_issue_comment(data["url"], pr_summary, pr_credit, data.get("title", ""))
+
+    for issue in data["closingIssuesReferences"]["nodes"]:
+        number = issue["number"]
+        event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/labels", json={"labels": ["fixed"]})
+        event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/comments", json={"body": comment})
 
-def remove_pr_labels(event, labels=()):
-    """Removes specified labels from PR."""
-    for label in labels:  # Can be extended with more labels in the future
-        event.delete(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{event.pr['number']}/labels/{label}")
+    return pr_credit
 
 
 def main(*args, **kwargs):
     """Summarize a pull request and update its description with a summary."""
     event = Action(*args, **kwargs)
+    action = event.event_data.get("action")
+    if action == "opened":
+        print("Skipping PR open - handled by first_interaction.py with unified API call")
+        return
+    if event.should_skip_openai():
+        return
 
     print(f"Retrieving diff for PR {event.pr['number']}")
     diff = event.get_pr_diff()
@@ -213,17 +111,18 @@ def main(*args, **kwargs):
 
     # Update PR description
     print("Updating PR description...")
-    update_pr_description(event, summary)
+    event.update_pr_description(event.pr["number"], summary)
 
-    # Update linked issues and post thank you message if merged
     if event.pr.get("merged"):
         print("PR is merged, labeling fixed issues...")
         pr_credit = label_fixed_issues(event, summary)
         print("Removing TODO label from PR...")
-        remove_pr_labels(event, labels=["TODO"])
+        event.remove_labels(event.pr["number"], labels=("TODO",))
         if pr_credit:
             print("Posting PR author thank you message...")
-            post_merge_message(event, summary, pr_credit)
+            pr_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{event.pr['number']}"
+            message = generate_merge_message(summary, pr_credit, pr_url)
+            event.add_comment(event.pr["number"], None, message, "pull request")
 
 
 if __name__ == "__main__":

actions/summarize_release.py

@@ -19,7 +19,7 @@ def get_release_diff(event, previous_tag: str, latest_tag: str) -> str:
     """Retrieves the differences between two specified Git tags in a GitHub repository."""
     url = f"{GITHUB_API_URL}/repos/{event.repository}/compare/{previous_tag}...{latest_tag}"
     r = event.get(url, headers=event.headers_diff)
-    return r.text if r.status_code == 200 else f"Failed to get diff: {r.content}"
+    return r.text if r.status_code == 200 else f"Failed to get diff: {r.text}"
 
 
 def get_prs_between_tags(event, previous_tag: str, latest_tag: str) -> list:
@@ -42,8 +42,8 @@ def get_prs_between_tags(event, previous_tag: str, latest_tag: str) -> list:
         pr_numbers.update(pr_matches)
 
     prs = []
-    time.sleep(10)  # sleep 10 seconds to allow final PR summary to update on merge
     for pr_number in sorted(pr_numbers):  # earliest to latest
+        time.sleep(1)  # Rate limit: GitHub search API has strict limits
         pr_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{pr_number}"
         pr_response = event.get(pr_url)
         if pr_response.status_code == 200:
@@ -52,7 +52,7 @@ def get_prs_between_tags(event, previous_tag: str, latest_tag: str) -> list:
                 {
                     "number": pr_data["number"],
                     "title": pr_data["title"],
-                    "body": remove_html_comments(pr_data["body"]),
+                    "body": remove_html_comments(pr_data.get("body", "")),
                     "author": pr_data["user"]["login"],
                     "html_url": pr_data["html_url"],
                     "merged_at": pr_data["merged_at"],
@@ -68,9 +68,15 @@ def get_prs_between_tags(event, previous_tag: str, latest_tag: str) -> list:
 def get_new_contributors(event, prs: list) -> set:
     """Identify new contributors who made their first merged PR in the current release."""
     new_contributors = set()
+    checked_authors = set()
     for pr in prs:
         author = pr["author"]
-        # Check if this is the author's first contribution
+        if author in checked_authors:
+            print(f"Skipping duplicate author: {author}")
+            continue
+        checked_authors.add(author)
+
+        time.sleep(2)  # Rate limit: GitHub search API has strict limits
         url = f"{GITHUB_API_URL}/search/issues?q=repo:{event.repository}+author:{author}+is:pr+is:merged&sort=created&order=asc"
         r = event.get(url)
         if r.status_code == 200:
@@ -79,6 +85,11 @@ def get_new_contributors(event, prs: list) -> set:
                 first_pr = data["items"][0]
                 if first_pr["number"] == pr["number"]:
                     new_contributors.add(author)
+        elif r.status_code == 403:
+            print(f"⚠️ Rate limit hit checking {author}, stopping contributor check")
+            break
+        else:
+            print(f"Failed to check {author}: {r.status_code}")
     return new_contributors
 
 
@@ -129,7 +140,7 @@ def generate_release_summary(
         },
         {
             "role": "user",
-            "content": f"Summarize the updates made in the '{latest_tag}' tag, focusing on major model or features changes, their purpose, and potential impact. Keep the summary clear and suitable for a broad audience. Add emojis to enliven the summary. Prioritize changes from the current PR (the first in the list), which is usually the most important in the release. Reply directly with a summary along these example guidelines, though feel free to adjust as appropriate:\n\n"
+            "content": f"Summarize the updates made in the '{latest_tag}' tag, focusing on major model or features changes, their purpose, and potential impact. Keep the summary clear and suitable for a broad audience. Add emojis to enliven the summary. Prioritize changes from the current PR (the last in the list), which is usually the most important in the release. Reply directly with a summary along these example guidelines, though feel free to adjust as appropriate:\n\n"
             f"## 🌟 Summary (single-line synopsis)\n"
             f"## 📊 Key Changes (bullet points highlighting any major changes)\n"
             f"## 🎯 Purpose & Impact (bullet points explaining any benefits and potential impact to users)\n\n\n"

actions/update_markdown_code_blocks.py

@@ -40,7 +40,6 @@ def add_indentation(code_block, num_spaces):
 def format_code_with_ruff(temp_dir):
     """Formats Python code files in the specified directory using ruff linter and docformatter tools."""
     if not next(Path(temp_dir).rglob("*.py"), None):
-        print("No Python code blocks found to format")
         return
 
     try:

actions/utils/__init__.py

@@ -9,7 +9,13 @@ from .common_utils import (
     remove_html_comments,
 )
 from .github_utils import GITHUB_API_URL, GITHUB_GRAPHQL_URL, Action, ultralytics_actions_info
-from .openai_utils import get_completion
+from .openai_utils import (
+    filter_labels,
+    get_completion,
+    get_pr_open_response,
+    get_pr_summary_guidelines,
+    get_pr_summary_prompt,
+)
 from .version_utils import check_pubdev_version, check_pypi_version
 
 __all__ = (
@@ -23,7 +29,11 @@ __all__ = (
     "allow_redirect",
     "check_pubdev_version",
     "check_pypi_version",
+    "filter_labels",
     "get_completion",
+    "get_pr_open_response",
+    "get_pr_summary_guidelines",
+    "get_pr_summary_prompt",
     "remove_html_comments",
     "ultralytics_actions_info",
 )