ultralytics-actions 0.1.0__tar.gz → 0.1.1__tar.gz

{ultralytics_actions-0.1.0/ultralytics_actions.egg-info → ultralytics_actions-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics-actions
-Version: 0.1.0
+Version: 0.1.1
 Summary: Ultralytics Actions for GitHub automation and PR management.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -64,6 +64,7 @@ Ultralytics Actions automatically applies formats, updates, and enhancements usi
 - **Spell Check:** Common misspellings are caught using [codespell](https://github.com/codespell-project/codespell).
 - **Broken Links Check:** Broken links in documentation and Markdown files are identified using [Lychee](https://github.com/lycheeverse/lychee).
 - **PR Summary:** Concise Pull Request summaries are generated using [OpenAI](https://openai.com/) GPT-5, improving clarity and review efficiency.
+- **PR Review:** AI-powered inline code reviews identify critical bugs, security issues, and code quality concerns with suggested fixes.
 - **Auto-labeling:** Relevant labels are applied to issues and pull requests via [OpenAI](https://openai.com/) GPT-5 for intelligent categorization.
 
 ## 🛠️ How It Works
@@ -74,6 +75,7 @@ Ultralytics Actions triggers on various GitHub events to streamline workflows:
 - **Pull Requests:**
   - Ensures contributions meet formatting standards before merging.
   - Generates a concise summary of changes using GPT-5.
+  - Provides AI-powered inline code reviews with suggested fixes for critical issues.
   - Applies relevant labels using GPT-5 for intelligent categorization.
 - **Issues:** Automatically applies relevant labels using GPT-5 when new issues are created.
 

{ultralytics_actions-0.1.0 → ultralytics_actions-0.1.1}/README.md

@@ -26,6 +26,7 @@ Ultralytics Actions automatically applies formats, updates, and enhancements usi
 - **Spell Check:** Common misspellings are caught using [codespell](https://github.com/codespell-project/codespell).
 - **Broken Links Check:** Broken links in documentation and Markdown files are identified using [Lychee](https://github.com/lycheeverse/lychee).
 - **PR Summary:** Concise Pull Request summaries are generated using [OpenAI](https://openai.com/) GPT-5, improving clarity and review efficiency.
+- **PR Review:** AI-powered inline code reviews identify critical bugs, security issues, and code quality concerns with suggested fixes.
 - **Auto-labeling:** Relevant labels are applied to issues and pull requests via [OpenAI](https://openai.com/) GPT-5 for intelligent categorization.
 
 ## 🛠️ How It Works
@@ -36,6 +37,7 @@ Ultralytics Actions triggers on various GitHub events to streamline workflows:
 - **Pull Requests:**
   - Ensures contributions meet formatting standards before merging.
   - Generates a concise summary of changes using GPT-5.
+  - Provides AI-powered inline code reviews with suggested fixes for critical issues.
   - Applies relevant labels using GPT-5 for intelligent categorization.
 - **Issues:** Automatically applies relevant labels using GPT-5 when new issues are created.
 

{ultralytics_actions-0.1.0 → ultralytics_actions-0.1.1}/actions/__init__.py

@@ -23,4 +23,4 @@
 #     ├── test_summarize_pr.py
 #     └── ...
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{ultralytics_actions-0.1.0 → ultralytics_actions-0.1.1}/actions/dispatch_actions.py

@@ -44,7 +44,7 @@ def trigger_and_get_workflow_info(event, branch: str) -> list[dict]:
         run_number = None
 
         runs_response = event.get(
-            f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}/runs?branch={branch}&event=workflow_dispatch&per_page=1",
+            f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}/runs?branch={branch}&event=workflow_dispatch&per_page=1"
         )
 
         if runs_response.status_code == 200:
@@ -57,10 +57,10 @@ def trigger_and_get_workflow_info(event, branch: str) -> list[dict]:
     return results
 
 
-def update_comment(event, comment_body: str, triggered_actions: list[dict], branch: str) -> bool:
+def update_comment(event, comment_body: str, triggered_actions: list[dict], branch: str):
     """Updates the comment with workflow information."""
     if not triggered_actions:
-        return False
+        return
 
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S UTC")
     summary = (

ultralytics_actions-0.1.1/actions/first_interaction.py

@@ -0,0 +1,218 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+import os
+import time
+
+from .utils import Action, filter_labels, get_completion, get_pr_open_response, remove_html_comments
+
+SUMMARY_START = (
+    "## 🛠️ PR Summary\n\n<sub>Made with ❤️ by [Ultralytics Actions](https://github.com/ultralytics/actions)<sub>\n\n"
+)
+BLOCK_USER = os.getenv("BLOCK_USER", "false").lower() == "true"
+
+
+def apply_and_check_labels(event, number, node_id, issue_type, username, labels, label_descriptions):
+    """Normalizes, applies labels, and handles Alert label if present."""
+    if not labels:
+        print("No relevant labels found or applied.")
+        return
+
+    available = {k.lower(): k for k in label_descriptions}
+    normalized = [available.get(label.lower(), label) for label in labels if label.lower() in available]
+
+    if normalized:
+        print(f"Applying labels: {normalized}")
+        event.apply_labels(number, node_id, normalized, issue_type)
+        if "Alert" in normalized and not event.is_org_member(username):
+            event.handle_alert(number, node_id, issue_type, username, block=BLOCK_USER)
+
+
+def get_event_content(event) -> tuple[int, str, str, str, str, str, str]:
+    """Extracts key information from GitHub event data for issues, pull requests, or discussions."""
+    data = event.event_data
+    name = event.event_name
+    action = data["action"]
+    if name == "issues":
+        item = data["issue"]
+        issue_type = "issue"
+    elif name in ["pull_request", "pull_request_target"]:
+        pr_number = data["pull_request"]["number"]
+        item = event.get_repo_data(f"pulls/{pr_number}")
+        issue_type = "pull request"
+    elif name == "discussion":
+        item = data["discussion"]
+        issue_type = "discussion"
+    else:
+        raise ValueError(f"Unsupported event type: {name}")
+
+    number = item["number"]
+    node_id = item.get("node_id") or item.get("id")
+    title = item["title"]
+    body = remove_html_comments(item.get("body", ""))
+    username = item["user"]["login"]
+    return number, node_id, title, body, username, issue_type, action
+
+
+def get_relevant_labels(
+    issue_type: str, title: str, body: str, available_labels: dict, current_labels: list
+) -> list[str]:
+    """Determines relevant labels for GitHub issues/discussions using OpenAI."""
+    filtered_labels = filter_labels(available_labels, current_labels, is_pr=(issue_type == "pull request"))
+    labels_str = "\n".join(f"- {name}: {description}" for name, description in filtered_labels.items())
+
+    prompt = f"""Select the top 1-3 most relevant labels for the following GitHub {issue_type}.
+
+INSTRUCTIONS:
+1. Review the {issue_type} title and description.
+2. Consider the available labels and their descriptions.
+3. Choose 1-3 labels that best match the {issue_type} content.
+4. Only use the "Alert" label when you have high confidence that this is an inappropriate {issue_type}.
+5. Respond ONLY with the chosen label names (no descriptions), separated by commas.
+6. If no labels are relevant, respond with 'None'.
+{'7. Only use the "bug" label if the user provides a clear description of the bug, their environment with relevant package versions and a minimum reproducible example.' if issue_type == "issue" else ""}
+
+AVAILABLE LABELS:
+{labels_str}
+
+{issue_type.upper()} TITLE:
+{title}
+
+{issue_type.upper()} DESCRIPTION:
+{body[:16000]}
+
+YOUR RESPONSE (label names only):
+"""
+    messages = [
+        {
+            "role": "system",
+            "content": "You are an Ultralytics AI assistant that labels GitHub issues, PRs, and discussions.",
+        },
+        {"role": "user", "content": prompt},
+    ]
+    suggested_labels = get_completion(messages, temperature=1.0)
+    if "none" in suggested_labels.lower():
+        return []
+
+    available_labels_lower = {name.lower(): name for name in filtered_labels}
+    return [
+        available_labels_lower[label.lower().strip()]
+        for label in suggested_labels.split(",")
+        if label.lower().strip() in available_labels_lower
+    ]
+
+
+def get_first_interaction_response(event, issue_type: str, title: str, body: str, username: str) -> str:
+    """Generates a custom LLM response for GitHub issues or discussions (NOT PRs - PRs use unified call)."""
+    issue_discussion_response = f"""
+👋 Hello @{username}, thank you for submitting a `{event.repository}` 🚀 {issue_type.capitalize()}. To help us address your concern efficiently, please ensure you've provided the following information:
+
+1. For bug reports:
+   - A clear and concise description of the bug
+   - A minimum reproducible example [MRE](https://docs.ultralytics.com/help/minimum-reproducible-example/) that demonstrates the issue
+   - Your environment details (OS, Python version, package versions)
+   - Expected behavior vs. actual behavior
+   - Any error messages or logs related to the issue
+
+2. For feature requests:
+   - A clear and concise description of the proposed feature
+   - The problem this feature would solve
+   - Any alternative solutions you've considered
+
+3. For questions:
+   - Provide as much context as possible about your question
+   - Include any research you've already done on the topic
+   - Specify which parts of the [documentation](https://docs.ultralytics.com/), if any, you've already consulted
+
+Please make sure you've searched existing {issue_type}s to avoid duplicates. If you need to add any additional information, please comment on this {issue_type}.
+
+Thank you for your contribution to improving our project!
+"""
+
+    example = os.getenv("FIRST_ISSUE_RESPONSE") or issue_discussion_response
+    org_name, repo_name = event.repository.split("/")
+
+    prompt = f"""Generate a customized response to the new GitHub {issue_type} below:
+
+CONTEXT:
+- Repository: {repo_name}
+- Organization: {org_name}
+- Repository URL: https://github.com/{event.repository}
+- User: {username}
+
+INSTRUCTIONS:
+- Do not answer the question or resolve the issue directly
+- Adapt the example {issue_type} response below as appropriate, keeping all badges, links and references provided
+- For bug reports, specifically request a minimum reproducible example (MRE) if not provided
+- INCLUDE ALL LINKS AND INSTRUCTIONS IN THE EXAMPLE BELOW, customized as appropriate
+- Mention to the user that this is an automated response and that an Ultralytics engineer will also assist soon
+- Do not add a sign-off or valediction like "best regards" at the end of your response
+- Do not add spaces between bullet points or numbered lists
+- Only link to files or URLs in the example below, do not add external links
+- Use a few emojis to enliven your response
+
+EXAMPLE {issue_type.upper()} RESPONSE:
+{example}
+
+{issue_type.upper()} TITLE:
+{title}
+
+{issue_type.upper()} DESCRIPTION:
+{body[:16000]}
+
+YOUR {issue_type.upper()} RESPONSE:
+"""
+    messages = [
+        {
+            "role": "system",
+            "content": f"You are an Ultralytics AI assistant responding to GitHub {issue_type}s for {org_name}.",
+        },
+        {"role": "user", "content": prompt},
+    ]
+    return get_completion(messages)
+
+
+def main(*args, **kwargs):
+    """Executes auto-labeling and custom response generation for new GitHub issues, PRs, and discussions."""
+    event = Action(*args, **kwargs)
+    number, node_id, title, body, username, issue_type, action = get_event_content(event)
+    available_labels = event.get_repo_data("labels")
+    label_descriptions = {label["name"]: label.get("description", "") for label in available_labels}
+
+    # Use unified PR open response for new PRs (summary + labels + first comment in 1 API call)
+    if issue_type == "pull request" and action == "opened":
+        print("Processing PR open with unified API call...")
+        diff = event.get_pr_diff()
+        response = get_pr_open_response(event.repository, diff, title, body, label_descriptions)
+
+        if summary := response.get("summary"):
+            print("Updating PR description with summary...")
+            event.update_pr_description(number, SUMMARY_START + summary)
+
+        if relevant_labels := response.get("labels", []):
+            apply_and_check_labels(event, number, node_id, issue_type, username, relevant_labels, label_descriptions)
+
+        if first_comment := response.get("first_comment"):
+            print("Adding first interaction comment...")
+            time.sleep(1)  # sleep to ensure label added first
+            event.add_comment(number, node_id, first_comment, issue_type)
+        return
+
+    # Handle issues and discussions (NOT PRs)
+    current_labels = (
+        []
+        if issue_type == "discussion"
+        else [label["name"].lower() for label in event.get_repo_data(f"issues/{number}/labels")]
+    )
+
+    relevant_labels = get_relevant_labels(issue_type, title, body, label_descriptions, current_labels)
+    apply_and_check_labels(event, number, node_id, issue_type, username, relevant_labels, label_descriptions)
+
+    if action in {"opened", "created"}:
+        custom_response = get_first_interaction_response(event, issue_type, title, body, username)
+        event.add_comment(number, node_id, custom_response, issue_type)
+
+
+if __name__ == "__main__":
+    main()

{ultralytics_actions-0.1.0 → ultralytics_actions-0.1.1}/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")