gtg 0.4.0__py3-none-any.whl

goodtogo/parsers/coderabbit.py

@@ -0,0 +1,352 @@
+"""CodeRabbit comment parser for GoodToMerge.
+
+This module implements the ReviewerParser interface for parsing comments
+from CodeRabbit, an AI-powered automated code review tool.
+
+CodeRabbit uses specific patterns to indicate comment severity and type:
+- Severity indicators with emojis and labels
+- Fingerprinting comments (internal metadata)
+- Resolution status markers
+- Outside diff range notifications
+- Summary/walkthrough sections (non-actionable)
+"""
+
+from __future__ import annotations
+
+import re
+
+from goodtogo.core.interfaces import ReviewerParser
+from goodtogo.core.models import CommentClassification, Priority, ReviewerType
+
+
+class CodeRabbitParser(ReviewerParser):
+    """Parser for CodeRabbit automated code review comments.
+
+    CodeRabbit posts comments with structured severity indicators that
+    can be deterministically parsed to classify comment actionability.
+
+    Patterns recognized:
+        - _Potential issue_ | _Critical/Major/Minor_: ACTIONABLE
+        - _Trivial_: NON_ACTIONABLE
+        - _Nitpick_: NON_ACTIONABLE
+        - Fingerprinting HTML comments: NON_ACTIONABLE
+        - Addressed checkmarks: NON_ACTIONABLE
+        - Outside diff range mentions: ACTIONABLE (MINOR)
+        - Summary/walkthrough sections: NON_ACTIONABLE
+        - Tip/info boxes: NON_ACTIONABLE
+        - All other: AMBIGUOUS
+
+    Author detection:
+        - Primary: author == "coderabbitai[bot]"
+        - Fallback: body contains CodeRabbit signature comment
+    """
+
+    # Author pattern for CodeRabbit bot
+    CODERABBIT_AUTHOR = "coderabbitai[bot]"
+
+    # Body pattern for CodeRabbit signature (fallback detection)
+    CODERABBIT_SIGNATURE_PATTERN = re.compile(
+        r"<!-- This is an auto-generated comment.*by coderabbit\.ai -->",
+        re.IGNORECASE | re.DOTALL,
+    )
+
+    # Severity patterns - using re.escape for literal characters
+    # Pattern: _Potential issue_ | _Critical/Major/Minor_
+    CRITICAL_PATTERN = re.compile(
+        r"_\u26a0\ufe0f\s*Potential issue_\s*\|\s*_\U0001f534\s*Critical_",
+        re.IGNORECASE,
+    )
+    MAJOR_PATTERN = re.compile(
+        r"_\u26a0\ufe0f\s*Potential issue_\s*\|\s*_\U0001f7e0\s*Major_",
+        re.IGNORECASE,
+    )
+    MINOR_PATTERN = re.compile(
+        r"_\u26a0\ufe0f\s*Potential issue_\s*\|\s*_\U0001f7e1\s*Minor_",
+        re.IGNORECASE,
+    )
+
+    # Non-actionable patterns
+    TRIVIAL_PATTERN = re.compile(r"_\U0001f535\s*Trivial_", re.IGNORECASE)
+    NITPICK_PATTERN = re.compile(r"_\U0001f9f9\s*Nitpick_", re.IGNORECASE)
+
+    # Fingerprinting comments (internal CodeRabbit metadata)
+    FINGERPRINT_PATTERN = re.compile(r"<!--\s*fingerprinting:", re.IGNORECASE)
+
+    # Addressed status marker
+    ADDRESSED_PATTERN = re.compile(r"\u2705\s*Addressed", re.IGNORECASE)
+
+    # Acknowledgment patterns (thank-you replies indicating issue was addressed)
+    # These are reply comments from CodeRabbit confirming a fix was applied
+    # Note: GitHub usernames can contain hyphens, so we use [\w-] instead of \w
+    ACKNOWLEDGMENT_PATTERNS = [
+        # "@username Thank you for the fix/catch/suggestion/addressing"
+        re.compile(
+            r"`?@[\w-]+`?\s+Thank\s+you\s+for\s+(the\s+)?(fix|catch|suggestion|addressing)",
+            re.IGNORECASE,
+        ),
+        # "Thank you for addressing this"
+        re.compile(r"Thank\s+you\s+for\s+addressing\s+this", re.IGNORECASE),
+        # Starts with "Thank you" and contains keywords like fix, addressed, suggestion
+        re.compile(
+            r"^`?@?[\w-]*`?\s*,?\s*[Tt]hank\s+you.*?(fix|addressed|updated|resolved|correct|suggestion)",
+            re.IGNORECASE,
+        ),
+    ]
+
+    # Outside diff range (in review body)
+    OUTSIDE_DIFF_PATTERN = re.compile(r"Outside diff range", re.IGNORECASE)
+
+    # Summary/walkthrough patterns (non-actionable informational content)
+    # These are overview sections that don't require action
+    SUMMARY_PATTERNS = [
+        # Walkthrough header
+        re.compile(r"^##\s*Walkthrough", re.MULTILINE),
+        # Changes summary header
+        re.compile(r"^##\s*Changes", re.MULTILINE),
+        # Summary header
+        re.compile(r"^##\s*Summary", re.MULTILINE),
+        # PR summary pattern
+        re.compile(r"^##\s*PR\s+Summary", re.MULTILINE | re.IGNORECASE),
+        # Review summary
+        re.compile(r"^##\s*Review\s+Summary", re.MULTILINE | re.IGNORECASE),
+        # File summary table pattern (CodeRabbit specific)
+        re.compile(r"\|\s*File\s*\|\s*Changes\s*\|", re.IGNORECASE),
+        # Sequence diagram indicators
+        re.compile(r"```mermaid", re.IGNORECASE),
+        # PR Objectives section
+        re.compile(r"^##\s*Objectives", re.MULTILINE | re.IGNORECASE),
+    ]
+
+    # Tip/info box patterns (non-actionable)
+    TIP_PATTERNS = [
+        re.compile(r"^>\s*\[!TIP\]", re.MULTILINE),
+        re.compile(r"^>\s*\[!NOTE\]", re.MULTILINE),
+        re.compile(r"^>\s*\[!INFO\]", re.MULTILINE),
+    ]
+
+    # PR-level summary comment patterns (non-actionable)
+    # These are posted at the PR level (path=None, line=None) and contain
+    # overview information. The actual actionable items are in inline comments.
+    PR_SUMMARY_PATTERNS = [
+        # "Actionable comments posted: N" pattern
+        re.compile(r"Actionable comments posted:\s*\d+", re.IGNORECASE),
+        # <details> sections with summaries
+        re.compile(r"<details>.*?<summary>.*?</summary>", re.IGNORECASE | re.DOTALL),
+        # CodeRabbit auto-generated comment signature
+        re.compile(
+            r"<!-- This is an auto-generated comment.*?by coderabbit",
+            re.IGNORECASE | re.DOTALL,
+        ),
+    ]
+
+    @property
+    def reviewer_type(self) -> ReviewerType:
+        """Return the reviewer type this parser handles.
+
+        Returns:
+            ReviewerType.CODERABBIT
+        """
+        return ReviewerType.CODERABBIT
+
+    def can_parse(self, author: str, body: str) -> bool:
+        """Check if this parser can handle the comment.
+
+        Identifies CodeRabbit comments by:
+        1. Author being "coderabbitai[bot]" (primary method)
+        2. Body containing CodeRabbit signature HTML comment (fallback)
+
+        Args:
+            author: Comment author's username/login.
+            body: Comment body text.
+
+        Returns:
+            True if this is a CodeRabbit comment, False otherwise.
+        """
+        # Primary detection: check author
+        if author == self.CODERABBIT_AUTHOR:
+            return True
+
+        # Fallback detection: check body for signature
+        if body and self.CODERABBIT_SIGNATURE_PATTERN.search(body):
+            return True
+
+        return False
+
+    def parse(self, comment: dict) -> tuple[CommentClassification, Priority, bool]:
+        """Parse CodeRabbit comment and return classification.
+
+        Analyzes the comment body to determine classification and priority
+        based on CodeRabbit's severity indicators.
+
+        Classification rules (in order of precedence):
+            1. PR-level summary comments -> NON_ACTIONABLE
+            2. Fingerprinting comments -> NON_ACTIONABLE
+            3. Addressed marker -> NON_ACTIONABLE
+            4. Critical severity -> ACTIONABLE, CRITICAL
+            5. Major severity -> ACTIONABLE, MAJOR
+            6. Minor severity -> ACTIONABLE, MINOR
+            7. Trivial severity -> NON_ACTIONABLE, TRIVIAL
+            8. Nitpick marker -> NON_ACTIONABLE, TRIVIAL
+            9. Outside diff range -> ACTIONABLE, MINOR
+            10. Summary/walkthrough sections -> NON_ACTIONABLE
+            11. Tip/info boxes -> NON_ACTIONABLE
+            12. All other -> AMBIGUOUS, UNKNOWN, requires_investigation=True
+
+        Args:
+            comment: Dictionary containing comment data with 'body' key,
+                and optionally 'path' and 'line' keys for inline comments.
+
+        Returns:
+            Tuple of (classification, priority, requires_investigation):
+            - classification: CommentClassification enum value
+            - priority: Priority enum value
+            - requires_investigation: Boolean, True for AMBIGUOUS comments
+        """
+        # Check for PR-level summary comments first (highest precedence)
+        # These are posted at the PR level and contain overview information
+        if self._is_pr_summary_comment(comment):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        body = comment.get("body", "")
+
+        # Early exit for empty body
+        if not body:
+            return (CommentClassification.AMBIGUOUS, Priority.UNKNOWN, True)
+
+        # Check fingerprinting comments first (internal metadata, ignore)
+        if self.FINGERPRINT_PATTERN.search(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        # Check addressed marker
+        if self.ADDRESSED_PATTERN.search(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        # Check acknowledgment patterns (thank-you replies)
+        if self._is_acknowledgment(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        # Check severity patterns (most specific first)
+        if self.CRITICAL_PATTERN.search(body):
+            return (CommentClassification.ACTIONABLE, Priority.CRITICAL, False)
+
+        if self.MAJOR_PATTERN.search(body):
+            return (CommentClassification.ACTIONABLE, Priority.MAJOR, False)
+
+        if self.MINOR_PATTERN.search(body):
+            return (CommentClassification.ACTIONABLE, Priority.MINOR, False)
+
+        # Check non-actionable patterns
+        if self.TRIVIAL_PATTERN.search(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.TRIVIAL, False)
+
+        if self.NITPICK_PATTERN.search(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.TRIVIAL, False)
+
+        # Check outside diff range (actionable but lower priority)
+        if self.OUTSIDE_DIFF_PATTERN.search(body):
+            return (CommentClassification.ACTIONABLE, Priority.MINOR, False)
+
+        # Check for summary/walkthrough sections (non-actionable informational)
+        if self._is_summary_content(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        # Check for tip/info boxes (non-actionable)
+        if self._is_tip_content(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        # Default: AMBIGUOUS - requires investigation
+        return (CommentClassification.AMBIGUOUS, Priority.UNKNOWN, True)
+
+    def _is_summary_content(self, body: str) -> bool:
+        """Check if the body is a summary/walkthrough section.
+
+        Summary sections are informational overviews that don't require
+        specific action. They include walkthroughs, change summaries,
+        and file tables.
+
+        Args:
+            body: Comment body text.
+
+        Returns:
+            True if the body appears to be a summary section.
+        """
+        for pattern in self.SUMMARY_PATTERNS:
+            if pattern.search(body):
+                return True
+        return False
+
+    def _is_tip_content(self, body: str) -> bool:
+        """Check if the body is a tip/info box.
+
+        Tip boxes are informational callouts that provide helpful
+        context but don't require action.
+
+        Args:
+            body: Comment body text.
+
+        Returns:
+            True if the body appears to be a tip/info box.
+        """
+        for pattern in self.TIP_PATTERNS:
+            if pattern.search(body):
+                return True
+        return False
+
+    def _is_acknowledgment(self, body: str) -> bool:
+        """Check if the body is an acknowledgment/thank-you reply.
+
+        Acknowledgment comments are replies from CodeRabbit confirming
+        that a fix or suggestion was addressed. These don't require action.
+
+        Args:
+            body: Comment body text.
+
+        Returns:
+            True if the body appears to be an acknowledgment.
+        """
+        for pattern in self.ACKNOWLEDGMENT_PATTERNS:
+            if pattern.search(body):
+                return True
+        return False
+
+    def _is_pr_summary_comment(self, comment: dict) -> bool:
+        """Check if this is a PR-level summary comment.
+
+        PR-level summary comments are posted at the PR level (not inline)
+        and contain overview information like "Actionable comments posted: N",
+        walkthrough sections, or CodeRabbit signatures. These should be
+        classified as NON_ACTIONABLE because the actual actionable items
+        are in inline comments.
+
+        Key criteria:
+        1. Must be a PR-level comment (path=None or missing)
+        2. Must match one of the PR summary patterns
+
+        Args:
+            comment: Dictionary containing comment data with 'body' key,
+                and optionally 'path' and 'line' keys.
+
+        Returns:
+            True if this is a PR-level summary comment that should be
+            classified as NON_ACTIONABLE.
+        """
+        # Only filter PR-level comments (path=None or missing)
+        # Never filter inline comments (they have path/line set)
+        path = comment.get("path")
+        if path is not None:
+            return False
+
+        body = comment.get("body", "")
+        if not body:
+            return False
+
+        # Check for PR summary patterns
+        for pattern in self.PR_SUMMARY_PATTERNS:
+            if pattern.search(body):
+                return True
+
+        # Also check for summary/walkthrough content at PR level
+        if self._is_summary_content(body):
+            return True
+
+        return False

goodtogo/parsers/cursor.py

@@ -0,0 +1,135 @@
+"""Cursor/Bugbot comment parser.
+
+This module implements the ReviewerParser interface for parsing comments
+from Cursor's Bugbot automated code reviewer.
+
+Cursor/Bugbot uses severity-based classification:
+- Critical Severity: Must fix immediately
+- High Severity: Must fix before merge
+- Medium Severity: Should fix
+- Low Severity: Nice to fix (non-actionable)
+"""
+
+from __future__ import annotations
+
+import re
+
+from goodtogo.core.interfaces import ReviewerParser
+from goodtogo.core.models import CommentClassification, Priority, ReviewerType
+
+
+class CursorBugbotParser(ReviewerParser):
+    """Parser for Cursor/Bugbot automated code review comments.
+
+    Detects comments from Cursor's Bugbot based on author patterns and
+    body content signatures. Classifies based on severity indicators
+    in the comment body.
+
+    Author patterns:
+        - "cursor[bot]"
+        - "cursor-bot"
+
+    Body signatures:
+        - cursor.com links
+        - Cursor-specific formatting
+
+    Severity mapping:
+        - Critical Severity -> ACTIONABLE, CRITICAL
+        - High Severity -> ACTIONABLE, MAJOR
+        - Medium Severity -> ACTIONABLE, MINOR
+        - Low Severity -> NON_ACTIONABLE, TRIVIAL
+        - No severity indicator -> AMBIGUOUS, UNKNOWN
+    """
+
+    # Author patterns that identify Cursor/Bugbot comments
+    _AUTHOR_PATTERNS = frozenset({"cursor[bot]", "cursor-bot"})
+
+    # Patterns in body that indicate Cursor/Bugbot origin
+    _CURSOR_BODY_SIGNATURES = (re.compile(r"cursor\.com", re.IGNORECASE),)
+
+    # Severity patterns and their classifications
+    _SEVERITY_PATTERNS = (
+        (
+            re.compile(r"Critical\s+Severity", re.IGNORECASE),
+            CommentClassification.ACTIONABLE,
+            Priority.CRITICAL,
+        ),
+        (
+            re.compile(r"High\s+Severity", re.IGNORECASE),
+            CommentClassification.ACTIONABLE,
+            Priority.MAJOR,
+        ),
+        (
+            re.compile(r"Medium\s+Severity", re.IGNORECASE),
+            CommentClassification.ACTIONABLE,
+            Priority.MINOR,
+        ),
+        (
+            re.compile(r"Low\s+Severity", re.IGNORECASE),
+            CommentClassification.NON_ACTIONABLE,
+            Priority.TRIVIAL,
+        ),
+    )
+
+    @property
+    def reviewer_type(self) -> ReviewerType:
+        """Return the reviewer type this parser handles.
+
+        Returns:
+            ReviewerType.CURSOR
+        """
+        return ReviewerType.CURSOR
+
+    def can_parse(self, author: str, body: str) -> bool:
+        """Check if this parser can handle the comment.
+
+        A comment can be parsed by this parser if:
+        1. The author matches known Cursor/Bugbot patterns, OR
+        2. The body contains Cursor-specific signatures
+
+        Args:
+            author: Comment author's username/login.
+            body: Comment body text.
+
+        Returns:
+            True if this parser can handle the comment, False otherwise.
+        """
+        # Check author patterns (case-insensitive)
+        author_lower = author.lower()
+        if author_lower in self._AUTHOR_PATTERNS:
+            return True
+
+        # Check body signatures
+        for pattern in self._CURSOR_BODY_SIGNATURES:
+            if pattern.search(body):
+                return True
+
+        return False
+
+    def parse(self, comment: dict) -> tuple[CommentClassification, Priority, bool]:
+        """Parse comment and return classification.
+
+        Analyzes the comment body for severity indicators to determine
+        classification and priority. Comments without a recognized
+        severity pattern are classified as AMBIGUOUS.
+
+        Args:
+            comment: Dictionary containing comment data with at least:
+                - 'body': Comment text content
+
+        Returns:
+            Tuple of (classification, priority, requires_investigation):
+            - classification: CommentClassification enum value
+            - priority: Priority enum value
+            - requires_investigation: True if AMBIGUOUS, False otherwise
+        """
+        body = comment.get("body", "")
+
+        # Check each severity pattern in order of priority
+        for pattern, classification, priority in self._SEVERITY_PATTERNS:
+            if pattern.search(body):
+                return classification, priority, False
+
+        # No recognized severity pattern - classify as ambiguous
+        # This requires investigation by the agent
+        return CommentClassification.AMBIGUOUS, Priority.UNKNOWN, True

goodtogo/parsers/generic.py

@@ -0,0 +1,192 @@
+"""Generic fallback parser for unknown reviewers.
+
+This module provides the GenericParser class, which serves as a fallback
+parser for comments that don't match any specific automated reviewer pattern.
+It handles human comments and unknown reviewer types.
+
+Per the design specification, the Generic Parser classification rules are:
+- Thread is resolved -> NON_ACTIONABLE
+- Thread is outdated -> NON_ACTIONABLE
+- Reply confirmation patterns -> NON_ACTIONABLE (acknowledging fixes)
+- Approval patterns (LGTM, etc.) -> NON_ACTIONABLE
+- All other -> AMBIGUOUS with requires_investigation=True
+"""
+
+from __future__ import annotations
+
+import re
+
+from goodtogo.core.interfaces import ReviewerParser
+from goodtogo.core.models import (
+    CommentClassification,
+    Priority,
+    ReviewerType,
+)
+
+
+class GenericParser(ReviewerParser):
+    """Fallback parser for unknown reviewers and human comments.
+
+    This parser is used when no specific reviewer parser matches the comment.
+    It applies conservative classification rules, marking most comments as
+    AMBIGUOUS to ensure nothing is silently skipped.
+
+    The GenericParser serves two purposes:
+    1. Handle comments from human reviewers (ReviewerType.HUMAN)
+    2. Act as a fallback for any unrecognized automated reviewers
+
+    Classification logic:
+    - Resolved threads -> NON_ACTIONABLE (already addressed)
+    - Outdated threads -> NON_ACTIONABLE (code has changed)
+    - Reply confirmation patterns -> NON_ACTIONABLE (acknowledging fixes)
+    - Approval patterns -> NON_ACTIONABLE (LGTM, looks good, etc.)
+    - All other comments -> AMBIGUOUS with requires_investigation=True
+
+    This conservative approach ensures that AI agents never miss potentially
+    important feedback by automatically dismissing it.
+    """
+
+    # Patterns indicating a reply that confirms something was addressed
+    # These are typically non-actionable acknowledgments
+    REPLY_CONFIRMATION_PATTERNS = [
+        # Explicit fix confirmations
+        re.compile(r"^(good\s+catch|great\s+catch|nice\s+catch)", re.IGNORECASE),
+        re.compile(r"^fixed\s+(in\s+)?(commit|[a-f0-9]{7})", re.IGNORECASE),
+        re.compile(r"^done[.!]?\s*$", re.IGNORECASE),
+        re.compile(r"^addressed[.!]?\s*$", re.IGNORECASE),
+        re.compile(r"^resolved[.!]?\s*$", re.IGNORECASE),
+        # Acknowledgments and thanks
+        re.compile(r"^thanks[!.,]?\s*$", re.IGNORECASE),
+        re.compile(r"^thank\s+you[!.,]?\s*$", re.IGNORECASE),
+        re.compile(r"^will\s+(fix|do|address|update)", re.IGNORECASE),
+        re.compile(r"^updated[.!]?\s*$", re.IGNORECASE),
+        re.compile(r"^applied[.!]?\s*$", re.IGNORECASE),
+        # Agreement patterns - must be complete confirmations, not prefixes
+        re.compile(r"^(yep|yeah|yes)[,.]?\s+(fixed|done|updated|addressed)", re.IGNORECASE),
+        re.compile(r"^agreed[,.]?\s*(fixed|done|updated)?[.!]?\s*$", re.IGNORECASE),
+        re.compile(r"^makes\s+sense[.!]?\s*$", re.IGNORECASE),
+    ]
+
+    # Patterns indicating approval or positive feedback (non-actionable)
+    APPROVAL_PATTERNS = [
+        re.compile(r"^lgtm[!.]?\s*$", re.IGNORECASE),
+        re.compile(r"^looks\s+good(\s+to\s+me)?[!.]?\s*$", re.IGNORECASE),
+        re.compile(r"^ship\s+it[!.]?\s*$", re.IGNORECASE),
+        re.compile(r"^\+1\s*$"),
+        re.compile(r"^:?\+1:?\s*$"),  # emoji format
+        re.compile(r"^approved[!.]?\s*$", re.IGNORECASE),
+    ]
+
+    @property
+    def reviewer_type(self) -> ReviewerType:
+        """Return ReviewerType.HUMAN.
+
+        The generic parser is used for human reviewers and as a fallback
+        for unknown reviewer types. HUMAN is returned as it's the most
+        appropriate classification for non-automated reviews.
+
+        Returns:
+            ReviewerType.HUMAN
+        """
+        return ReviewerType.HUMAN
+
+    def can_parse(self, author: str, body: str) -> bool:
+        """Return True for all comments.
+
+        As the fallback parser, GenericParser accepts all comments that
+        weren't matched by more specific parsers. This ensures no comments
+        are dropped or unhandled.
+
+        Args:
+            author: Comment author's username/login (ignored).
+            body: Comment body text (ignored).
+
+        Returns:
+            Always True - this is the catch-all parser.
+        """
+        return True
+
+    def parse(self, comment: dict) -> tuple[CommentClassification, Priority, bool]:
+        """Parse comment and return classification.
+
+        Classification logic:
+        1. Resolved threads -> NON_ACTIONABLE
+        2. Outdated threads -> NON_ACTIONABLE
+        3. Reply confirmation patterns -> NON_ACTIONABLE
+        4. Approval patterns -> NON_ACTIONABLE
+        5. All other -> AMBIGUOUS with requires_investigation=True
+
+        Note: This parser intentionally does NOT try to interpret comment
+        content for actionability. That would be unreliable for human comments.
+        Instead, it relies on metadata (resolved/outdated status) and simple
+        patterns that indicate the comment has been addressed.
+
+        Args:
+            comment: Dictionary containing comment data with:
+                - 'body': Comment text content (optional)
+                - 'is_resolved': Boolean indicating if thread is resolved
+                - 'is_outdated': Boolean indicating if comment is outdated
+
+        Returns:
+            Tuple of (classification, priority, requires_investigation):
+            - classification: CommentClassification enum value
+            - priority: Priority.UNKNOWN (generic parser doesn't assess priority)
+            - requires_investigation: True for AMBIGUOUS, False otherwise
+        """
+        # Check if thread is resolved
+        if comment.get("is_resolved", False):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        # Check if thread is outdated
+        if comment.get("is_outdated", False):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        body = comment.get("body", "")
+
+        # Check for reply confirmation patterns (acknowledging fixes)
+        if self._is_reply_confirmation(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        # Check for approval patterns (LGTM, looks good, etc.)
+        if self._is_approval(body):
+            return (CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False)
+
+        # All other cases: AMBIGUOUS with requires_investigation=True
+        # Critical: AMBIGUOUS comments MUST always have requires_investigation=True
+        return (CommentClassification.AMBIGUOUS, Priority.UNKNOWN, True)
+
+    def _is_reply_confirmation(self, body: str) -> bool:
+        """Check if the body is a reply confirmation.
+
+        Reply confirmations are comments that acknowledge something was
+        addressed or fixed, such as "Good catch!", "Fixed in commit abc123", etc.
+
+        Args:
+            body: Comment body text.
+
+        Returns:
+            True if the body appears to be a reply confirmation.
+        """
+        body_stripped = body.strip()
+        for pattern in self.REPLY_CONFIRMATION_PATTERNS:
+            if pattern.search(body_stripped):
+                return True
+        return False
+
+    def _is_approval(self, body: str) -> bool:
+        """Check if the body is an approval comment.
+
+        Approval comments are positive feedback that indicate the code
+        is acceptable, such as "LGTM", "Looks good", "+1", etc.
+
+        Args:
+            body: Comment body text.
+
+        Returns:
+            True if the body appears to be an approval.
+        """
+        body_stripped = body.strip()
+        for pattern in self.APPROVAL_PATTERNS:
+            if pattern.search(body_stripped):
+                return True
+        return False