PR2MD 1.0.1__py3-none-any.whl

pr2md/__init__.py

@@ -0,0 +1,21 @@
+"""PR2MD - Pull Request to Markdown Exporter.
+
+A tool for extracting GitHub Pull Request data and formatting it as Markdown.
+"""
+
+from pr2md.formatter import MarkdownFormatter
+from pr2md.models import Comment, Label, PullRequest, Review, ReviewComment, User
+from pr2md.pr_extractor import GitHubAPIError, GitHubPRExtractor
+
+__version__ = "1.0.1"
+__all__ = [
+    "Comment",
+    "Label",
+    "PullRequest",
+    "Review",
+    "ReviewComment",
+    "User",
+    "GitHubAPIError",
+    "GitHubPRExtractor",
+    "MarkdownFormatter",
+]

pr2md/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running pr2md as a module."""
+
+from pr2md.cli import main
+
+if __name__ == "__main__":
+    main()

pr2md/cli.py

@@ -0,0 +1,236 @@
+"""Command-line interface for GitHub PR extractor."""
+
+import argparse
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Optional
+
+from pr2md.formatter import MarkdownFormatter
+from pr2md.pr_extractor import GitHubAPIError, GitHubPRExtractor
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """
+    Set up logging configuration.
+
+    Args:
+        verbose: Enable verbose logging
+    """
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+
+def parse_pr_url(url: str) -> tuple[str, str, int]:
+    """
+    Parse GitHub PR URL to extract owner, repo, and PR number.
+
+    Args:
+        url: GitHub PR URL
+
+    Returns:
+        Tuple of (owner, repo, pr_number)
+
+    Raises:
+        ValueError: If URL is invalid
+    """
+    pattern = r"https?://github\.com/([^/]+)/([^/]+)/pull/(\d+)"
+    match = re.match(pattern, url)
+    if not match:
+        raise ValueError(
+            f"Invalid GitHub PR URL: {url}\n"
+            "Expected format: https://github.com/owner/repo/pull/123"
+        )
+    owner, repo, pr_number_str = match.groups()
+    return str(owner), str(repo), int(pr_number_str)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """
+    Create command-line argument parser.
+
+    Returns:
+        Configured ArgumentParser
+    """
+    parser = argparse.ArgumentParser(
+        description="Extract GitHub Pull Request details to Markdown format",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s https://github.com/owner/repo/pull/123
+  %(prog)s owner repo 123
+  %(prog)s https://github.com/owner/repo/pull/123 -o output.md
+  %(prog)s owner repo 123 --output pr-details.md --verbose
+        """,
+    )
+
+    parser.add_argument(
+        "pr_identifier",
+        nargs="+",
+        help=(
+            "GitHub PR URL (https://github.com/owner/repo/pull/123) "
+            "or owner repo pr_number"
+        ),
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        help="Output file path (default: stdout)",
+        default=None,
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose logging",
+    )
+
+    return parser
+
+
+def parse_arguments(
+    parser: argparse.ArgumentParser,
+) -> tuple[str, str, int, Optional[str], bool]:
+    """
+    Parse command-line arguments and extract PR details.
+
+    Args:
+        parser: Argument parser
+
+    Returns:
+        Tuple of (owner, repo, pr_number, output_path, verbose)
+    """
+    args = parser.parse_args()
+    logger = logging.getLogger(__name__)
+
+    # Initialize variables to satisfy pylint - they will be assigned in all code paths
+    owner: str = ""
+    repo: str = ""
+    pr_number: int = 0
+
+    # Parse PR identifier
+    try:
+        pr_args: list[str] = list(args.pr_identifier)
+        if len(pr_args) == 1:
+            # URL format
+            owner, repo, pr_number = parse_pr_url(str(pr_args[0]))
+        elif len(pr_args) == 3:
+            # owner repo pr_number format
+            owner = str(pr_args[0])
+            repo = str(pr_args[1])
+            pr_number = int(pr_args[2])
+        else:
+            parser.error(
+                "Invalid arguments. Provide either a PR URL or owner repo pr_number"
+            )
+    except (ValueError, IndexError) as err:
+        logger.error("Error parsing PR identifier: %s", err)
+        sys.exit(1)
+
+    output_path: Optional[str] = str(args.output) if args.output else None
+    verbose: bool = bool(args.verbose)
+
+    return owner, repo, pr_number, output_path, verbose
+
+
+def extract_pr_data(
+    owner: str, repo: str, pr_number: int, verbose: bool
+) -> tuple[str, bool]:
+    """
+    Extract PR data and format as Markdown.
+
+    Args:
+        owner: Repository owner
+        repo: Repository name
+        pr_number: PR number
+        verbose: Enable verbose logging
+
+    Returns:
+        Tuple of (markdown, success)
+    """
+    logger = logging.getLogger(__name__)
+
+    # Extract PR data
+    try:
+        extractor = GitHubPRExtractor(owner, repo, pr_number)
+        pull_request, comments, reviews, review_comments, diff = extractor.extract_all()
+    except GitHubAPIError as err:
+        logger.error("GitHub API error: %s", err)
+        return "", False
+    except Exception as err:  # pylint: disable=broad-exception-caught
+        logger.error("Unexpected error: %s", err)
+        if verbose:
+            logger.exception("Full traceback:")
+        return "", False
+
+    # Format as Markdown
+    try:
+        markdown = MarkdownFormatter.format_pr(
+            pull_request, comments, reviews, review_comments, diff
+        )
+        return markdown, True
+    except Exception as err:  # pylint: disable=broad-exception-caught
+        logger.error("Error formatting data: %s", err)
+        if verbose:
+            logger.exception("Full traceback:")
+        return "", False
+
+
+def write_output(markdown: str, output_path: Optional[str], verbose: bool) -> bool:
+    """
+    Write markdown output to file or stdout.
+
+    Args:
+        markdown: Formatted markdown string
+        output_path: Optional output file path
+        verbose: Enable verbose logging
+
+    Returns:
+        True if successful, False otherwise
+    """
+    logger = logging.getLogger(__name__)
+
+    try:
+        if output_path:
+            Path(output_path).write_text(markdown, encoding="utf-8")
+            logger.info("Output written to %s", output_path)
+        else:
+            print(markdown)  # noqa: T201
+        return True
+    except Exception as err:  # pylint: disable=broad-exception-caught
+        logger.error("Error writing output: %s", err)
+        if verbose:
+            logger.exception("Full traceback:")
+        return False
+
+
+def main() -> None:
+    """Main entry point for the CLI."""
+    parser = create_parser()
+    owner, repo, pr_number, output_path, verbose = parse_arguments(parser)
+
+    setup_logging(verbose)
+    logger = logging.getLogger(__name__)
+
+    logger.info("Extracting PR %s/%s #%d", owner, repo, pr_number)
+
+    markdown, success = extract_pr_data(owner, repo, pr_number, verbose)
+    if not success:
+        sys.exit(1)
+
+    if not write_output(markdown, output_path, verbose):
+        sys.exit(1)
+
+    logger.info("Extraction completed successfully")
+
+
+if __name__ == "__main__":
+    main()

pr2md/formatter.py

@@ -0,0 +1,231 @@
+"""Markdown formatter for GitHub PR data."""
+
+import logging
+from collections import defaultdict
+
+from pr2md.models import Comment, PullRequest, Review, ReviewComment
+
+logger = logging.getLogger(__name__)
+
+
+class MarkdownFormatter:
+    """Format GitHub PR data as Markdown."""
+
+    @staticmethod
+    def format_pr(
+        pull_request: PullRequest,
+        comments: list[Comment],
+        reviews: list[Review],
+        review_comments: list[ReviewComment],
+        diff: str,
+    ) -> str:
+        """
+        Format all PR data as Markdown.
+
+        Args:
+            pull_request: Pull request object
+            comments: List of comments
+            reviews: List of reviews
+            review_comments: List of review comments
+            diff: Diff string
+
+        Returns:
+            Formatted Markdown string
+        """
+        logger.info("Formatting PR data as Markdown")
+        sections = [
+            MarkdownFormatter._format_header(pull_request),
+            MarkdownFormatter._format_description(pull_request),
+            MarkdownFormatter._format_changes_summary(pull_request),
+            MarkdownFormatter._format_diff(diff),
+            MarkdownFormatter._format_conversation(comments),
+            MarkdownFormatter._format_reviews(reviews),
+            MarkdownFormatter._format_review_comments(review_comments),
+        ]
+
+        result = "\n\n".join(sections)
+        logger.info("Formatted Markdown (%d characters)", len(result))
+        return result
+
+    @staticmethod
+    def _format_header(pull_request: PullRequest) -> str:
+        """Format PR header section."""
+        status = pull_request.state.upper()
+        if pull_request.merged_at:
+            status = "MERGED"
+
+        labels_str = ""
+        if pull_request.labels:
+            label_names = ", ".join(
+                [f"`{label.name}`" for label in pull_request.labels]
+            )
+            labels_str = f"\n**Labels:** {label_names}"
+
+        closed_str = ""
+        if pull_request.closed_at:
+            closed_time = pull_request.closed_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+            closed_str = f"\n**Closed:** {closed_time}"
+
+        merged_str = ""
+        if pull_request.merged_at:
+            merged_time = pull_request.merged_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+            merged_str = f"\n**Merged:** {merged_time}"
+
+        created_time = pull_request.created_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+        updated_time = pull_request.updated_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+
+        return f"""# {pull_request.title}
+
+**PR Number:** #{pull_request.number}
+**Status:** {status}
+**Author:** [{pull_request.user.login}]({pull_request.user.html_url})
+**Created:** {created_time}
+**Updated:** {updated_time}{closed_str}{merged_str}
+**URL:** {pull_request.html_url}
+**Base:** `{pull_request.base_ref}` (`{pull_request.base_sha[:7]}`)
+**Head:** `{pull_request.head_ref}` (`{pull_request.head_sha[:7]}`){labels_str}"""
+
+    @staticmethod
+    def _format_description(pull_request: PullRequest) -> str:
+        """Format PR description section."""
+        if not pull_request.body:
+            return "## Description\n\n*No description provided.*"
+        return f"## Description\n\n{pull_request.body}"
+
+    @staticmethod
+    def _format_changes_summary(pull_request: PullRequest) -> str:
+        """Format changes summary section."""
+        return f"""## Changes Summary
+
+- **Files changed:** {pull_request.changed_files}
+- **Additions:** +{pull_request.additions}
+- **Deletions:** -{pull_request.deletions}"""
+
+    @staticmethod
+    def _format_diff(diff: str) -> str:
+        """Format diff section."""
+        if not diff:
+            return "## Code Diff\n\n*No diff available.*"
+
+        return f"""## Code Diff
+
+```diff
+{diff}
+```"""
+
+    @staticmethod
+    def _format_conversation(comments: list[Comment]) -> str:
+        """Format conversation thread section."""
+        if not comments:
+            return "## Conversation Thread\n\n*No comments in the conversation thread.*"
+
+        # Sort by creation time
+        sorted_comments = sorted(comments, key=lambda c: c.created_at)
+
+        formatted_comments = []
+        for comment in sorted_comments:
+            comment_time = comment.created_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+            # pylint: disable=line-too-long
+            formatted_comment = f"""### [{comment.user.login}]({comment.user.html_url}) commented on {comment_time}
+
+{comment.body}
+
+*[View on GitHub]({comment.html_url})*"""
+            # pylint: enable=line-too-long
+            formatted_comments.append(formatted_comment)
+
+        return "## Conversation Thread\n\n" + "\n\n---\n\n".join(formatted_comments)
+
+    @staticmethod
+    def _format_reviews(reviews: list[Review]) -> str:
+        """Format reviews section."""
+        if not reviews:
+            return "## Reviews\n\n*No reviews submitted.*"
+
+        # Sort by submission time
+        sorted_reviews = sorted(
+            reviews,
+            key=lambda r: r.submitted_at if r.submitted_at else r.user.login,
+        )
+
+        formatted_reviews = []
+        for review in sorted_reviews:
+            submitted_str = (
+                review.submitted_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+                if review.submitted_at
+                else "Unknown date"
+            )
+
+            state_emoji: dict[str, str] = {
+                "APPROVED": "✅",
+                "CHANGES_REQUESTED": "🔴",
+                "COMMENTED": "💬",
+                "DISMISSED": "🚫",
+                "PENDING": "⏳",
+            }
+            emoji = state_emoji.get(review.state, "")
+
+            body_str = review.body if review.body else "*No comment provided.*"
+
+            # pylint: disable=line-too-long
+            formatted_review = f"""### {emoji} [{review.user.login}]({review.user.html_url}) {review.state.replace("_", " ")} on {submitted_str}
+
+{body_str}
+
+*[View on GitHub]({review.html_url})*"""
+            # pylint: enable=line-too-long
+            formatted_reviews.append(formatted_review)
+
+        return "## Reviews\n\n" + "\n\n---\n\n".join(formatted_reviews)
+
+    @staticmethod
+    def _format_review_comments(review_comments: list[ReviewComment]) -> str:
+        """Format review comments section."""
+        if not review_comments:
+            return "## Review Comments (Code Comments)\n\n*No review comments on code.*"
+
+        # Group by file path
+        comments_by_file: dict[str, list[ReviewComment]] = defaultdict(list)
+        for comment in review_comments:
+            comments_by_file[comment.path].append(comment)
+
+        # Sort files alphabetically
+        sorted_files = sorted(comments_by_file.keys())
+
+        formatted_files = []
+        for file_path in sorted_files:
+            file_comments = sorted(
+                comments_by_file[file_path], key=lambda c: c.created_at
+            )
+
+            formatted_comments = []
+            for comment in file_comments:
+                # Check if this is a reply
+                reply_str = ""
+                if comment.in_reply_to_id:
+                    reply_str = f" *(in reply to comment #{comment.in_reply_to_id})*"
+
+                comment_time = comment.created_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+                # pylint: disable=line-too-long
+                formatted_comment = f"""#### [{comment.user.login}]({comment.user.html_url}) commented on {comment_time}{reply_str}
+
+**Code context:**
+```diff
+{comment.diff_hunk}
+```
+
+**Comment:**
+{comment.body}
+
+*[View on GitHub]({comment.html_url})*"""
+                # pylint: enable=line-too-long
+                formatted_comments.append(formatted_comment)
+
+            file_section = f"""### File: `{file_path}`
+
+{chr(10).join(formatted_comments)}"""
+            formatted_files.append(file_section)
+
+        return "## Review Comments (Code Comments)\n\n" + "\n\n---\n\n".join(
+            formatted_files
+        )

pr2md/models.py

@@ -0,0 +1,225 @@
+"""Data models for GitHub PR extraction."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Optional
+
+
+@dataclass
+class User:
+    """GitHub user information."""
+
+    login: str
+    id: int
+    avatar_url: str
+    html_url: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "User":
+        """Create User from API response dictionary."""
+        return cls(
+            login=str(data["login"]),
+            id=int(data["id"]),
+            avatar_url=str(data["avatar_url"]),
+            html_url=str(data["html_url"]),
+        )
+
+
+@dataclass
+class Label:
+    """GitHub label information."""
+
+    name: str
+    color: str
+    description: Optional[str]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Label":
+        """Create Label from API response dictionary."""
+        return cls(
+            name=str(data["name"]),
+            color=str(data["color"]),
+            description=(
+                str(data["description"])
+                if data.get("description") is not None
+                else None
+            ),
+        )
+
+
+@dataclass
+class Comment:
+    """GitHub issue/PR comment."""
+
+    id: int
+    user: User
+    body: str
+    created_at: datetime
+    updated_at: datetime
+    html_url: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Comment":
+        """Create Comment from API response dictionary."""
+        return cls(
+            id=int(data["id"]),
+            user=User.from_dict(dict(data["user"])),
+            body=str(data["body"]),
+            created_at=datetime.fromisoformat(
+                str(data["created_at"]).replace("Z", "+00:00")
+            ),
+            updated_at=datetime.fromisoformat(
+                str(data["updated_at"]).replace("Z", "+00:00")
+            ),
+            html_url=str(data["html_url"]),
+        )
+
+
+@dataclass
+class ReviewComment:
+    """GitHub review comment (inline code comment)."""
+
+    id: int
+    user: User
+    body: str
+    path: str
+    position: Optional[int]
+    original_position: Optional[int]
+    commit_id: str
+    original_commit_id: str
+    diff_hunk: str
+    created_at: datetime
+    updated_at: datetime
+    html_url: str
+    in_reply_to_id: Optional[int]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ReviewComment":
+        """Create ReviewComment from API response dictionary."""
+        return cls(
+            id=int(data["id"]),
+            user=User.from_dict(dict(data["user"])),
+            body=str(data["body"]),
+            path=str(data["path"]),
+            position=int(data["position"]) if data.get("position") else None,
+            original_position=(
+                int(data["original_position"])
+                if data.get("original_position")
+                else None
+            ),
+            commit_id=str(data["commit_id"]),
+            original_commit_id=str(data["original_commit_id"]),
+            diff_hunk=str(data["diff_hunk"]),
+            created_at=datetime.fromisoformat(
+                str(data["created_at"]).replace("Z", "+00:00")
+            ),
+            updated_at=datetime.fromisoformat(
+                str(data["updated_at"]).replace("Z", "+00:00")
+            ),
+            html_url=str(data["html_url"]),
+            in_reply_to_id=(
+                int(data["in_reply_to_id"]) if data.get("in_reply_to_id") else None
+            ),
+        )
+
+
+@dataclass
+class Review:
+    """GitHub PR review."""
+
+    id: int
+    user: User
+    body: Optional[str]
+    state: str
+    html_url: str
+    submitted_at: Optional[datetime]
+    commit_id: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Review":
+        """Create Review from API response dictionary."""
+        submitted_at = None
+        if data.get("submitted_at"):
+            submitted_at = datetime.fromisoformat(
+                str(data["submitted_at"]).replace("Z", "+00:00")
+            )
+
+        return cls(
+            id=int(data["id"]),
+            user=User.from_dict(dict(data["user"])),
+            body=str(data["body"]) if data.get("body") is not None else None,
+            state=str(data["state"]),
+            html_url=str(data["html_url"]),
+            submitted_at=submitted_at,
+            commit_id=str(data["commit_id"]),
+        )
+
+
+@dataclass
+class PullRequest:
+    """GitHub Pull Request."""
+
+    number: int
+    title: str
+    body: Optional[str]
+    state: str
+    user: User
+    created_at: datetime
+    updated_at: datetime
+    closed_at: Optional[datetime]
+    merged_at: Optional[datetime]
+    merge_commit_sha: Optional[str]
+    html_url: str
+    labels: list[Label]
+    additions: int
+    deletions: int
+    changed_files: int
+    head_ref: str
+    base_ref: str
+    head_sha: str
+    base_sha: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PullRequest":
+        """Create PullRequest from API response dictionary."""
+        closed_at = None
+        if data.get("closed_at"):
+            closed_at = datetime.fromisoformat(
+                str(data["closed_at"]).replace("Z", "+00:00")
+            )
+
+        merged_at = None
+        if data.get("merged_at"):
+            merged_at = datetime.fromisoformat(
+                str(data["merged_at"]).replace("Z", "+00:00")
+            )
+
+        return cls(
+            number=int(data["number"]),
+            title=str(data["title"]),
+            body=str(data["body"]) if data.get("body") is not None else None,
+            state=str(data["state"]),
+            user=User.from_dict(dict(data["user"])),
+            created_at=datetime.fromisoformat(
+                str(data["created_at"]).replace("Z", "+00:00")
+            ),
+            updated_at=datetime.fromisoformat(
+                str(data["updated_at"]).replace("Z", "+00:00")
+            ),
+            closed_at=closed_at,
+            merged_at=merged_at,
+            merge_commit_sha=(
+                str(data["merge_commit_sha"])
+                if data.get("merge_commit_sha") is not None
+                else None
+            ),
+            html_url=str(data["html_url"]),
+            labels=[Label.from_dict(dict(label)) for label in list(data["labels"])],
+            additions=int(data["additions"]),
+            deletions=int(data["deletions"]),
+            changed_files=int(data["changed_files"]),
+            head_ref=str(data["head"]["ref"]),
+            base_ref=str(data["base"]["ref"]),
+            head_sha=str(data["head"]["sha"]),
+            base_sha=str(data["base"]["sha"]),
+        )

pr2md/pr_extractor.py

@@ -0,0 +1,190 @@
+"""GitHub Pull Request data extraction."""
+
+import logging
+from typing import Any, Optional
+
+import requests
+
+from pr2md.models import Comment, PullRequest, Review, ReviewComment
+
+logger = logging.getLogger(__name__)
+
+
+class GitHubAPIError(Exception):
+    """Exception raised for GitHub API errors."""
+
+
+class GitHubPRExtractor:
+    """Extract Pull Request data from GitHub API."""
+
+    def __init__(self, owner: str, repo: str, pr_number: int) -> None:
+        """
+        Initialize the PR extractor.
+
+        Args:
+            owner: Repository owner
+            repo: Repository name
+            pr_number: Pull request number
+        """
+        self.owner = owner
+        self.repo = repo
+        self.pr_number = pr_number
+        self.base_url = "https://api.github.com"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Accept": "application/vnd.github.v3+json",
+                "User-Agent": "GitHub-PR-Extractor",
+            }
+        )
+        logger.info("Initialized extractor for %s/%s PR #%d", owner, repo, pr_number)
+
+    def _make_request(self, endpoint: str, accept_header: Optional[str] = None) -> Any:
+        """
+        Make a request to the GitHub API.
+
+        Args:
+            endpoint: API endpoint path
+            accept_header: Optional custom Accept header
+
+        Returns:
+            Response data (JSON or text)
+
+        Raises:
+            GitHubAPIError: If the request fails
+        """
+        url = f"{self.base_url}{endpoint}"
+        headers = {}
+        if accept_header:
+            headers["Accept"] = accept_header
+
+        logger.debug("Making request to %s", url)
+        response = self.session.get(url, headers=headers, timeout=30)
+
+        if response.status_code == 404:
+            raise GitHubAPIError(
+                f"Resource not found: {url}. "
+                "Please check that the repository and PR number are correct."
+            )
+        if response.status_code == 403:
+            # Check if it's rate limiting
+            if "rate limit" in response.text.lower():
+                raise GitHubAPIError(
+                    "GitHub API rate limit exceeded. "
+                    "Please try again later or use authentication."
+                )
+            raise GitHubAPIError(f"Access forbidden: {url}")
+        if response.status_code != 200:
+            raise GitHubAPIError(
+                f"GitHub API request failed with status {response.status_code}: "
+                f"{response.text}"
+            )
+
+        if accept_header and "diff" in accept_header:
+            return str(response.text)
+        return response.json()
+
+    def fetch_pr_details(self) -> PullRequest:
+        """
+        Fetch pull request details.
+
+        Returns:
+            PullRequest object
+
+        Raises:
+            GitHubAPIError: If the request fails
+        """
+        logger.info("Fetching PR details")
+        endpoint = f"/repos/{self.owner}/{self.repo}/pulls/{self.pr_number}"
+        data: dict[str, Any] = self._make_request(endpoint)
+        return PullRequest.from_dict(data)
+
+    def fetch_comments(self) -> list[Comment]:
+        """
+        Fetch issue/PR comments (conversation thread).
+
+        Returns:
+            List of Comment objects
+
+        Raises:
+            GitHubAPIError: If the request fails
+        """
+        logger.info("Fetching comments")
+        endpoint = f"/repos/{self.owner}/{self.repo}/issues/{self.pr_number}/comments"
+        data: list[dict[str, Any]] = self._make_request(endpoint)
+        comments = [Comment.from_dict(dict(comment)) for comment in data]
+        logger.info("Found %d comments", len(comments))
+        return comments
+
+    def fetch_review_comments(self) -> list[ReviewComment]:
+        """
+        Fetch review comments (inline code comments).
+
+        Returns:
+            List of ReviewComment objects
+
+        Raises:
+            GitHubAPIError: If the request fails
+        """
+        logger.info("Fetching review comments")
+        endpoint = f"/repos/{self.owner}/{self.repo}/pulls/{self.pr_number}/comments"
+        data: list[dict[str, Any]] = self._make_request(endpoint)
+        review_comments = [ReviewComment.from_dict(dict(comment)) for comment in data]
+        logger.info("Found %d review comments", len(review_comments))
+        return review_comments
+
+    def fetch_reviews(self) -> list[Review]:
+        """
+        Fetch PR reviews.
+
+        Returns:
+            List of Review objects
+
+        Raises:
+            GitHubAPIError: If the request fails
+        """
+        logger.info("Fetching reviews")
+        endpoint = f"/repos/{self.owner}/{self.repo}/pulls/{self.pr_number}/reviews"
+        data: list[dict[str, Any]] = self._make_request(endpoint)
+        reviews = [Review.from_dict(dict(review)) for review in data]
+        logger.info("Found %d reviews", len(reviews))
+        return reviews
+
+    def fetch_diff(self) -> str:
+        """
+        Fetch PR diff.
+
+        Returns:
+            Diff as a string
+
+        Raises:
+            GitHubAPIError: If the request fails
+        """
+        logger.info("Fetching diff")
+        endpoint = f"/repos/{self.owner}/{self.repo}/pulls/{self.pr_number}"
+        diff: str = self._make_request(
+            endpoint, accept_header="application/vnd.github.v3.diff"
+        )
+        logger.info("Fetched diff (%d bytes)", len(diff))
+        return diff
+
+    def extract_all(
+        self,
+    ) -> tuple[PullRequest, list[Comment], list[Review], list[ReviewComment], str]:
+        """
+        Extract all PR data.
+
+        Returns:
+            Tuple of (PullRequest, comments, reviews, review_comments, diff)
+
+        Raises:
+            GitHubAPIError: If any request fails
+        """
+        logger.info("Extracting all PR data")
+        pull_request = self.fetch_pr_details()
+        comments = self.fetch_comments()
+        reviews = self.fetch_reviews()
+        review_comments = self.fetch_review_comments()
+        diff = self.fetch_diff()
+        logger.info("Successfully extracted all PR data")
+        return pull_request, comments, reviews, review_comments, diff

pr2md-1.0.1.dist-info/METADATA

@@ -0,0 +1,317 @@
+Metadata-Version: 2.4
+Name: PR2MD
+Version: 1.0.1
+Summary: Pull Request Markdown Generator
+Author: tboy1337
+License: MIT
+Project-URL: Homepage, https://github.com/tboy1337/PR2MD
+Project-URL: Repository, https://github.com/tboy1337/PR2MD
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: license-file
+
+# PR2MD - Pull Request to Markdown
+
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+[![License: CRL](https://img.shields.io/badge/License-CRL-red.svg)](LICENSE.md)
+
+**PR2MD** is a powerful command-line tool that extracts GitHub Pull Request data and converts it into comprehensive, well-formatted Markdown documents. Perfect for documentation, archiving, code reviews, or offline analysis of pull requests.
+
+## Features
+
+- 📥 **Complete PR Data Extraction**: Retrieves all PR details including metadata, description, labels, and timestamps
+- 💬 **Full Conversation Thread**: Captures all comments and discussions in chronological order
+- ✅ **Review Information**: Includes all code reviews with approval status and reviewer comments
+- 💻 **Code Comments**: Extracts inline review comments with their associated code context
+- 📊 **Change Statistics**: Displays files changed, additions, deletions, and commit information
+- 🔍 **Complete Diffs**: Includes the full unified diff of all changes
+- 🎨 **Beautiful Formatting**: Generates clean, readable Markdown with proper structure and syntax highlighting
+- ⚡ **Fast & Efficient**: Uses the official GitHub REST API with proper error handling
+- 🔒 **Type-Safe**: Written in Python with comprehensive type annotations
+
+## Installation
+
+### From Source
+
+```bash
+# Clone the repository
+git clone https://github.com/tboy1337/PR2MD.git
+cd PR2MD
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Install the package
+pip install -e .
+```
+
+### Requirements
+
+- Python 3.13 or higher
+- `requests` library (for GitHub API communication)
+
+## Usage
+
+### Basic Usage
+
+Extract a PR using its URL:
+
+```bash
+pr2md https://github.com/owner/repo/pull/123
+```
+
+Or specify the owner, repository, and PR number separately:
+
+```bash
+pr2md owner repo 123
+```
+
+### Save to File
+
+Output the Markdown to a file instead of stdout:
+
+```bash
+pr2md https://github.com/owner/repo/pull/123 -o pr-details.md
+pr2md owner repo 123 --output pr-analysis.md
+```
+
+### Verbose Logging
+
+Enable detailed logging for debugging:
+
+```bash
+pr2md https://github.com/owner/repo/pull/123 --verbose
+```
+
+### Help
+
+View all available options:
+
+```bash
+pr2md --help
+```
+
+## Output Format
+
+The generated Markdown document includes:
+
+### 1. PR Header
+- PR number, title, and status (Open/Closed/Merged)
+- Author information with GitHub profile link
+- Creation, update, closed, and merged timestamps
+- Base and head branch information with commit SHAs
+- Labels (if any)
+
+### 2. Description
+- The full PR description/body
+
+### 3. Changes Summary
+- Number of files changed
+- Line additions and deletions
+
+### 4. Code Diff
+- Complete unified diff of all changes
+- Syntax-highlighted code blocks
+
+### 5. Conversation Thread
+- All comments from the PR discussion
+- Chronologically sorted
+- Author attribution and timestamps
+- Links back to GitHub
+
+### 6. Reviews
+- All submitted reviews
+- Review state (Approved ✅, Changes Requested 🔴, Commented 💬, etc.)
+- Review comments and timestamps
+
+### 7. Review Comments (Code Comments)
+- Inline code review comments
+- Grouped by file
+- Includes code context (diff hunk)
+- Reply chains preserved
+
+## Example
+
+```bash
+# Extract PR #42 from the PR2MD repository
+pr2md tboy1337 PR2MD 42 -o pr-42.md
+```
+
+This creates a file `pr-42.md` containing all the PR information in a beautifully formatted Markdown document.
+
+## GitHub API Rate Limiting
+
+The tool uses the GitHub REST API without authentication by default. GitHub imposes rate limits:
+
+- **Unauthenticated requests**: 60 requests per hour
+- **Authenticated requests**: 5,000 requests per hour
+
+For most use cases, unauthenticated access is sufficient as the tool makes only a few API calls per PR. If you encounter rate limiting issues, the tool will provide clear error messages.
+
+**Future Enhancement**: Authentication support is planned for a future release to enable higher rate limits and access to private repositories.
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/tboy1337/PR2MD.git
+cd PR2MD
+
+# Install development dependencies
+pip install -r requirements-dev.txt
+
+# Install the package in editable mode
+pip install -e .
+```
+
+### Running Tests
+
+The project includes comprehensive tests using pytest:
+
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=pr2md --cov-report=html
+
+# Run specific test file
+pytest tests/test_cli.py
+
+# Run with verbose output
+pytest -v
+```
+
+### Code Quality
+
+The project maintains high code quality standards:
+
+```bash
+# Type checking with mypy
+mypy src/pr2md
+
+# Linting with pylint
+pylint src/pr2md
+
+# Code formatting with black
+black src/pr2md tests
+
+# Import sorting with isort
+isort src/pr2md tests
+
+# Remove trailing whitespace
+py -m autopep8 --in-place --select=W291,W293 src tests
+```
+
+### Project Structure
+
+```
+PR2MD/
+├── src/
+│   └── pr2md/
+│       ├── __init__.py
+│       ├── __main__.py      # Entry point
+│       ├── cli.py           # Command-line interface
+│       ├── models.py        # Data models
+│       ├── pr_extractor.py  # GitHub API client
+│       ├── formatter.py     # Markdown formatter
+│       └── py.typed         # Type checking marker
+├── tests/                   # Comprehensive test suite
+├── pyproject.toml          # Project configuration
+├── requirements.txt        # Runtime dependencies
+├── requirements-dev.txt    # Development dependencies
+├── mypy.ini               # Type checking configuration
+├── pytest.ini             # Test configuration
+└── README.md              # This file
+```
+
+## Architecture
+
+### Core Components
+
+1. **CLI Module** (`cli.py`): Handles command-line argument parsing, logging setup, and orchestrates the extraction and formatting process.
+
+2. **PR Extractor** (`pr_extractor.py`): Communicates with the GitHub REST API to fetch PR data, comments, reviews, and diffs. Includes comprehensive error handling.
+
+3. **Models** (`models.py`): Type-safe data classes representing GitHub entities (PullRequest, Comment, Review, ReviewComment, User, Label).
+
+4. **Formatter** (`formatter.py`): Converts structured PR data into beautifully formatted Markdown with proper sections and syntax highlighting.
+
+### Design Principles
+
+- **Type Safety**: Full type annotations throughout the codebase
+- **Error Handling**: Graceful handling of API errors and edge cases
+- **Logging**: Comprehensive logging for debugging and monitoring
+- **Testability**: Modular design with clear separation of concerns
+- **Extensibility**: Easy to add new features or output formats
+
+## Use Cases
+
+- **Code Review Documentation**: Archive code reviews for compliance or historical reference
+- **Offline Analysis**: Review PRs without internet connectivity
+- **Pull Request Templates**: Learn from well-structured PRs
+- **Change Management**: Document significant changes in projects
+- **Training Materials**: Create educational resources from real-world code reviews
+- **Audit Trails**: Maintain records of development decisions
+- **Report Generation**: Include PR details in project reports
+
+## Limitations
+
+- Currently supports only public GitHub repositories (authentication coming soon)
+- Rate limited by GitHub API (60 requests/hour without authentication)
+- Requires internet connection to fetch data
+- Large PRs with extensive diffs may generate very large Markdown files
+
+## Roadmap
+
+- [ ] GitHub authentication support (personal access tokens)
+- [ ] Support for GitHub Enterprise
+- [ ] Private repository access
+- [ ] Batch processing of multiple PRs
+- [ ] Custom output templates
+- [ ] Additional output formats (HTML, PDF)
+- [ ] Diff filtering and summarization
+- [ ] PR comparison tool
+- [ ] Integration with CI/CD pipelines
+
+## Contributing
+
+This project is maintained by tboy1337. Contributions, issues, and feature requests are welcome! Feel free to check the [issues page](https://github.com/tboy1337/PR2MD/issues).
+
+## License
+
+This project is licensed under the **Commercial Restricted License (CRL) Version 1.1**.
+
+**Summary:**
+- ✅ **Free for non-commercial use** (personal, educational, research, open source)
+- ❌ **Commercial use requires a separate commercial license**
+- 📧 Contact the copyright holder for commercial licensing inquiries
+
+See the [LICENSE.md](LICENSE.md) file for the complete license text.
+
+## Author
+
+**tboy1337**
+- GitHub: [@tboy1337](https://github.com/tboy1337)
+
+## Acknowledgments
+
+- Built with Python 3.13+
+- Uses the [GitHub REST API](https://docs.github.com/en/rest)
+- Inspired by the need for better PR documentation tools
+
+---
+
+**Made with ❤️ for the developer community**
+

pr2md-1.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+pr2md/__init__.py,sha256=VFRYcFv1Y_5bsSnO_evEQPKYHtawYPAvp4P7-jPtY1E,547
+pr2md/__main__.py,sha256=v1ZnD7wEzDbUi1jOplNEezAE2lGqs8hazSR-fp8-va0,122
+pr2md/cli.py,sha256=Gwws5MXg7BUEI7z8ncADQwhaVweM3mmB2gn-EcUpFfE,6725
+pr2md/formatter.py,sha256=4L6P7udNlYeEQcIU59uNYeG-DIWp5nx67YCyZ9b1UnE,8122
+pr2md/models.py,sha256=L67GK-G48YcjadysFJ0u_AMV62PHBqp-D_VN4RROAvU,6739
+pr2md/pr_extractor.py,sha256=5aDPCRu_AVdDZ9_jOX5l7qkcmnSh0gzoKIUCca9ro3Y,6328
+pr2md/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pr2md-1.0.1.dist-info/licenses/LICENSE.md,sha256=NYP65MjIOiBIzSEUIwUQw56lJYkP_7nGPFfgIgyl-iI,3035
+pr2md-1.0.1.dist-info/METADATA,sha256=QKE-I8tVh-5IuzzvusoyKjl8Lg9wdpBvRxT_3-diGHM,9500
+pr2md-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pr2md-1.0.1.dist-info/entry_points.txt,sha256=r-BbhudThY0lrrEhlT3iq6GzEMyVzh-fBPOUZl3Z-yQ,46
+pr2md-1.0.1.dist-info/top_level.txt,sha256=smkBu5Jubu9z2ItjJY8ekPudzTnXyoe74EXLHHtGGwc,6
+pr2md-1.0.1.dist-info/RECORD,,

pr2md-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pr2md-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pr2md = pr2md.__main__:main

pr2md-1.0.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,70 @@
+# Commercial Restricted License (CRL)
+
+**Version 1.1**
+
+**Copyright (c) 2025 tboy1337**
+
+## Grant of Rights
+
+Subject to the terms and conditions of this license, the copyright holder grants you a worldwide, royalty-free, non-exclusive license to use, copy, modify, and distribute this software and associated documentation files (the "Software") for **Non-Commercial Use** only.
+
+## Definitions
+
+**"Non-Commercial Use"** means use of the Software that is not primarily intended for or directed toward commercial advantage or monetary compensation. Non-Commercial Use includes:
+
+- Personal use, learning, and experimentation
+- Academic research and education
+- Open source projects that are not monetized
+- Internal evaluation within a commercial organization (limited to 30 days)
+- Use by registered non-profit organizations for their non-profit activities
+
+**"Commercial Use"** means any use of the Software that is primarily intended for or directed toward commercial advantage or monetary compensation, including but not limited to:
+
+- Use in any product or service that generates revenue
+- Use by for-profit organizations in their business operations
+- Integration into commercial software or services
+- Use in providing paid consulting, support, or services
+- Use in any business process that contributes to revenue generation
+- Use by organizations with annual revenue exceeding $100,000 USD
+
+**Note:** Any Commercial Use of the Software requires a separate commercial license from the copyright holder.
+
+## Conditions
+
+For Non-Commercial Use, you may:
+
+- Use, copy, and modify the Software
+- Distribute copies of the Software
+- Distribute your modifications under this same license
+
+You must:
+
+- Include this license notice in all copies or substantial portions of the Software
+- Not remove or alter any copyright notices
+
+## Restrictions
+
+You may not:
+
+- Use the Software for Commercial Use without a commercial license
+- Sublicense the Software under different terms
+- Use the Software in any way that violates applicable laws
+- Remove, obscure, or modify any licensing, copyright, or other legal notices
+
+## No Warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## Termination
+
+This license terminates automatically if you violate any of its terms. Upon termination, you must cease all use and distribution of the Software and destroy all copies in your possession.
+
+## Governing Law
+
+This license shall be governed by and construed in accordance with the laws of the United Kingdom, without regard to its conflict of law provisions.

pr2md-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pr2md