ultralytics-actions 0.1.0__py3-none-any.whl → 0.1.1__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,27 +55,36 @@ 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 = (
@@ -65,16 +92,28 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
         "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"
         "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"
+        "- Never include 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,16 @@ 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 = (
+        "REQUEST_CHANGES" if any(c.get("severity") not in ["LOW", "SUGGESTION", None] for c in comments) else "APPROVE"
+    )
 
     body = (
         f"## {review_title}\n\n"
@@ -205,15 +247,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,
     )
 
 
@@ -238,8 +316,6 @@ def main(*args, **kwargs):
     review = generate_pr_review(event.repository, diff, event.pr.get("title", ""), event.pr.get("body", ""))
 
     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,46 @@ 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
 
     print(f"Retrieving diff for PR {event.pr['number']}")
     diff = event.get_pr_diff()
@@ -213,17 +110,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

@@ -42,7 +42,7 @@ 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
+    time.sleep(10)  # Allow final PR summary to update on merge
     for pr_number in sorted(pr_numbers):  # earliest to latest
         pr_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{pr_number}"
         pr_response = event.get(pr_url)
@@ -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
 
 

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",
 )