git-recap 0.1.3__tar.gz → 0.1.4__tar.gz

{git_recap-0.1.3 → git_recap-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-recap
-Version: 0.1.3
+Version: 0.1.4
 Summary: A modular Python tool that aggregates and formats user-authored messages from repositories.
 Author: Bruno V.
 Author-email: bruno.vitorino@tecnico.ulisboa.pt
@@ -21,8 +21,16 @@ Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 
+<a href="https://www.uneed.best/tool/gitrecap">
+  <img src="https://www.uneed.best/POTD2A.png" style="width: 250px;" alt="Uneed POTD2 Badge" />
+</a>
+
+---
+
 # Git Recap
 
+🎉 **Featured in Uneed's Latest Newsletter as a Staff Pick!** 🎉
+
 Git Recap is a modular Python tool that aggregates and formats user-authored messages from repositories hosted on GitHub, Azure DevOps, and GitLab. It fetches commit messages, pull requests (along with their associated commits), and issues, then consolidates and sorts these events into a clear, chronological summary. This summary is output as a plain text string that can serve as context for large language models or other analysis tools.
 
 ## Features

{git_recap-0.1.3 → git_recap-0.1.4}/README.md

@@ -1,5 +1,13 @@
+<a href="https://www.uneed.best/tool/gitrecap">
+  <img src="https://www.uneed.best/POTD2A.png" style="width: 250px;" alt="Uneed POTD2 Badge" />
+</a>
+
+---
+
 # Git Recap
 
+🎉 **Featured in Uneed's Latest Newsletter as a Staff Pick!** 🎉
+
 Git Recap is a modular Python tool that aggregates and formats user-authored messages from repositories hosted on GitHub, Azure DevOps, and GitLab. It fetches commit messages, pull requests (along with their associated commits), and issues, then consolidates and sorts these events into a clear, chronological summary. This summary is output as a plain text string that can serve as context for large language models or other analysis tools.
 
 ## Features
@@ -110,4 +118,4 @@ This project is licensed under the terms of the [MIT License](LICENSE).
 
 - [PyGitHub](https://pygithub.readthedocs.io/en/stable/)
 - [Azure DevOps Python API](https://github.com/microsoft/azure-devops-python-api)
-- [python-gitlab](https://python-gitlab.readthedocs.io/)
+- [python-gitlab](https://python-gitlab.readthedocs.io/)

{git_recap-0.1.3 → git_recap-0.1.4}/git_recap/providers/azure_fetcher.py

@@ -5,8 +5,25 @@ from typing import List, Dict, Any
 from git_recap.providers.base_fetcher import BaseFetcher
 
 class AzureFetcher(BaseFetcher):
+    """
+    Fetcher implementation for Azure DevOps repositories.
+
+    Supports fetching commits, pull requests, and issues.
+    Release fetching is not supported and will raise NotImplementedError.
+    """
+
     def __init__(self, pat: str, organization_url: str, start_date=None, end_date=None, repo_filter=None, authors=None):
-        # authors should be passed as a list of unique names (e.g., email or unique id)
+        """
+        Initialize the AzureFetcher.
+
+        Args:
+            pat (str): Personal Access Token for Azure DevOps.
+            organization_url (str): The Azure DevOps organization URL.
+            start_date (datetime, optional): Start date for filtering entries.
+            end_date (datetime, optional): End date for filtering entries.
+            repo_filter (List[str], optional): List of repository names to filter.
+            authors (List[str], optional): List of author identifiers (e.g., email or unique id).
+        """
         super().__init__(pat, start_date, end_date, repo_filter, authors)
         self.organization_url = organization_url
         credentials = BasicAuthentication('', self.pat)
@@ -20,17 +37,37 @@ class AzureFetcher(BaseFetcher):
             self.authors = []
 
     def get_repos(self):
+        """
+        Retrieve all repositories in all projects for the organization.
+        Returns:
+            List of repository objects.
+        """
         projects = self.core_client.get_projects().value
         # Get all repositories in each project
         repos = [self.git_client.get_repositories(project.id) for project in projects]
         return repos
 
     @property
-    def repos_names(self)->List[str]:
-        "to be implemented later"
+    def repos_names(self) -> List[str]:
+        """
+        Return the list of repository names.
+
+        Returns:
+            List[str]: List of repository names.
+        """
+        # To be implemented if needed for UI or listing.
         ...
 
     def _filter_by_date(self, date_obj: datetime) -> bool:
+        """
+        Check if a datetime object is within the configured date range.
+
+        Args:
+            date_obj (datetime): The datetime to check.
+
+        Returns:
+            bool: True if within range, False otherwise.
+        """
         if self.start_date and date_obj < self.start_date:
             return False
         if self.end_date and date_obj > self.end_date:
@@ -38,11 +75,26 @@ class AzureFetcher(BaseFetcher):
         return True
 
     def _stop_fetching(self, date_obj: datetime) -> bool:
+        """
+        Determine if fetching should stop based on the date.
+
+        Args:
+            date_obj (datetime): The datetime to check.
+
+        Returns:
+            bool: True if should stop, False otherwise.
+        """
         if self.start_date and date_obj < self.start_date:
             return True
         return False
 
     def fetch_commits(self) -> List[Dict[str, Any]]:
+        """
+        Fetch commits for all repositories and authors.
+
+        Returns:
+            List[Dict[str, Any]]: List of commit entries.
+        """
         entries = []
         processed_commits = set()
         for repo in self.repos:
@@ -77,6 +129,12 @@ class AzureFetcher(BaseFetcher):
         return entries
 
     def fetch_pull_requests(self) -> List[Dict[str, Any]]:
+        """
+        Fetch pull requests and their associated commits for all repositories and authors.
+
+        Returns:
+            List[Dict[str, Any]]: List of pull request and commit_from_pr entries.
+        """
         entries = []
         processed_pr_commits = set()
         projects = self.core_client.get_projects().value
@@ -138,6 +196,12 @@ class AzureFetcher(BaseFetcher):
         return entries
 
     def fetch_issues(self) -> List[Dict[str, Any]]:
+        """
+        Fetch issues (work items) assigned to the configured authors.
+
+        Returns:
+            List[Dict[str, Any]]: List of issue entries.
+        """
         entries = []
         wit_client = self.connection.clients.get_work_item_tracking_client()
         # Query work items for each author using a simplified WIQL query.
@@ -160,4 +224,16 @@ class AzureFetcher(BaseFetcher):
                     entries.append(entry)
                 if self._stop_fetching(created_date):
                     break
-        return entries
+        return entries
+
+    def fetch_releases(self) -> List[Dict[str, Any]]:
+        """
+        Fetch releases for Azure DevOps repositories.
+
+        Not implemented for Azure DevOps.
+
+        Raises:
+            NotImplementedError: Always, since release fetching is not supported for AzureFetcher.
+        """
+        # If Azure DevOps release fetching is supported in the future, implement logic here.
+        raise NotImplementedError("Release fetching is not supported for Azure DevOps (AzureFetcher).")

{git_recap-0.1.3 → git_recap-0.1.4}/git_recap/providers/base_fetcher.py

@@ -9,7 +9,7 @@ class BaseFetcher(ABC):
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
         repo_filter: Optional[List[str]] = None,
-        authors: Optional[List[str]]=None
+        authors: Optional[List[str]] = None
     ):
         self.pat = pat
         if start_date is not None:
@@ -28,32 +28,82 @@ class BaseFetcher(ABC):
 
     @property
     @abstractmethod
-    def repos_names(self)->List[str]:
+    def repos_names(self) -> List[str]:
+        """
+        Return the list of repository names accessible to this fetcher.
+
+        Returns:
+            List[str]: List of repository names.
+        """
         pass
-        
+
     @abstractmethod
-    def fetch_commits(self) -> List[str]:
+    def fetch_commits(self) -> List[Dict[str, Any]]:
+        """
+        Fetch commit entries for the configured repositories and authors.
+
+        Returns:
+            List[Dict[str, Any]]: List of commit entries.
+        """
         pass
 
     @abstractmethod
-    def fetch_pull_requests(self) -> List[str]:
+    def fetch_pull_requests(self) -> List[Dict[str, Any]]:
+        """
+        Fetch pull request entries for the configured repositories and authors.
+
+        Returns:
+            List[Dict[str, Any]]: List of pull request entries.
+        """
         pass
 
     @abstractmethod
-    def fetch_issues(self) -> List[str]:
+    def fetch_issues(self) -> List[Dict[str, Any]]:
+        """
+        Fetch issue entries for the configured repositories and authors.
+
+        Returns:
+            List[Dict[str, Any]]: List of issue entries.
+        """
         pass
 
+    @abstractmethod
+    def fetch_releases(self) -> List[Dict[str, Any]]:
+        """
+        Fetch releases for all repositories accessible to this fetcher.
+
+        Returns:
+            List[Dict[str, Any]]: List of releases, each as a structured dictionary.
+                The dictionary should include at least:
+                  - tag_name: str
+                  - name: str
+                  - repo: str
+                  - author: str
+                  - published_at: datetime
+                  - created_at: datetime
+                  - draft: bool
+                  - prerelease: bool
+                  - body: str
+                  - assets: List[Dict[str, Any]] (if available)
+        Raises:
+            NotImplementedError: If the provider does not support release fetching.
+        """
+        raise NotImplementedError("Release fetching is not implemented for this provider.")
+
     def get_authored_messages(self) -> List[Dict[str, Any]]:
         """
         Aggregates all commit, pull request, and issue entries into a single list,
         ensuring no duplicate commits (based on SHA) are present, and then sorts
         them in chronological order based on their timestamp.
+
+        Returns:
+            List[Dict[str, Any]]: Aggregated and sorted list of entries.
         """
         commit_entries = self.fetch_commits()
         pr_entries = self.fetch_pull_requests()
         try:
             issue_entries = self.fetch_issues()
-        except Exception as e:
+        except Exception:
             issue_entries = []
 
         all_entries = pr_entries + commit_entries + issue_entries
@@ -75,11 +125,17 @@ class BaseFetcher(ABC):
         # Sort all entries by their timestamp.
         final_entries.sort(key=lambda x: x["timestamp"])
         return self.convert_timestamps_to_str(final_entries)
-    
+
     @staticmethod
     def convert_timestamps_to_str(entries: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         """
         Converts the timestamp field from datetime to string format for each entry in the list.
+
+        Args:
+            entries (List[Dict[str, Any]]): List of entries with possible datetime timestamps.
+
+        Returns:
+            List[Dict[str, Any]]: Entries with timestamps as ISO-formatted strings.
         """
         for entry in entries:
             if isinstance(entry.get("timestamp"), datetime):

{git_recap-0.1.3 → git_recap-0.1.4}/git_recap/providers/github_fetcher.py

@@ -4,15 +4,21 @@ from typing import List, Dict, Any
 from git_recap.providers.base_fetcher import BaseFetcher
 
 class GitHubFetcher(BaseFetcher):
+    """
+    Fetcher implementation for GitHub repositories.
+
+    Supports fetching commits, pull requests, issues, and releases.
+    """
+
     def __init__(self, pat: str, start_date=None, end_date=None, repo_filter=None, authors=None):
         super().__init__(pat, start_date, end_date, repo_filter, authors)
         self.github = Github(self.pat)
-        self.user = self.github.get_user()        
+        self.user = self.github.get_user()
         self.repos = self.user.get_repos(affiliation="owner,collaborator,organization_member")
         self.authors.append(self.user.login)
 
     @property
-    def repos_names(self)->List[str]:
+    def repos_names(self) -> List[str]:
         return [repo.name for repo in self.repos]
 
     def _stop_fetching(self, date_obj: datetime) -> bool:
@@ -101,7 +107,6 @@ class GitHubFetcher(BaseFetcher):
                     break
         return entries
 
-
     def fetch_issues(self) -> List[Dict[str, Any]]:
         entries = []
         issues = self.user.get_issues()
@@ -117,4 +122,56 @@ class GitHubFetcher(BaseFetcher):
                 entries.append(entry)
             if self._stop_fetching(issue_date):
                 break
-        return entries
+        return entries
+
+    def fetch_releases(self) -> List[Dict[str, Any]]:
+        """
+        Fetch releases for all repositories accessible to the user.
+
+        Returns:
+            List[Dict[str, Any]]: List of releases, each as a structured dictionary with:
+                - tag_name: str
+                - name: str
+                - repo: str
+                - author: str
+                - published_at: datetime
+                - created_at: datetime
+                - draft: bool
+                - prerelease: bool
+                - body: str
+                - assets: List[Dict[str, Any]] (each with name, size, download_url, content_type, etc.)
+        """
+        releases = []
+        for repo in self.repos:
+            if self.repo_filter and repo.name not in self.repo_filter:
+                continue
+            try:
+                for rel in repo.get_releases():
+                    # Compose asset list
+                    assets = []
+                    for asset in rel.get_assets():
+                        assets.append({
+                            "name": asset.name,
+                            "size": asset.size,
+                            "download_url": asset.browser_download_url,
+                            "content_type": asset.content_type,
+                            "created_at": asset.created_at,
+                            "updated_at": asset.updated_at,
+                        })
+                    release_entry = {
+                        "tag_name": rel.tag_name,
+                        "name": rel.title if hasattr(rel, "title") else rel.name,
+                        "repo": repo.name,
+                        "author": rel.author.login if rel.author else None,
+                        "published_at": rel.published_at,
+                        "created_at": rel.created_at,
+                        "draft": rel.draft,
+                        "prerelease": rel.prerelease,
+                        "body": rel.body,
+                        "assets": assets,
+                    }
+                    releases.append(release_entry)
+            except Exception:
+                # If fetching releases fails for a repo, skip it (could be permissions or no releases)
+                continue
+        return releases

{git_recap-0.1.3 → git_recap-0.1.4}/git_recap/providers/gitlab_fetcher.py

@@ -4,11 +4,37 @@ from typing import List, Dict, Any
 from git_recap.providers.base_fetcher import BaseFetcher
 
 class GitLabFetcher(BaseFetcher):
-    def __init__(self, pat: str, url: str = 'https://gitlab.com', start_date=None, end_date=None, repo_filter=None, authors=None):
+    """
+    Fetcher implementation for GitLab repositories.
+
+    Supports fetching commits, merge requests (pull requests), and issues.
+    Release fetching is not supported and will raise NotImplementedError.
+    """
+
+    def __init__(
+        self,
+        pat: str,
+        url: str = 'https://gitlab.com',
+        start_date=None,
+        end_date=None,
+        repo_filter=None,
+        authors=None
+    ):
+        """
+        Initialize the GitLabFetcher.
+
+        Args:
+            pat (str): Personal Access Token for GitLab.
+            url (str): The GitLab instance URL.
+            start_date (datetime, optional): Start date for filtering entries.
+            end_date (datetime, optional): End date for filtering entries.
+            repo_filter (List[str], optional): List of repository names to filter.
+            authors (List[str], optional): List of author usernames.
+        """
         super().__init__(pat, start_date, end_date, repo_filter, authors)
         self.gl = gitlab.Gitlab(url, private_token=self.pat)
         self.gl.auth()
-        # Instead of only owned projects, retrieve projects where you're a member.
+        # Retrieve projects where the user is a member.
         self.projects = self.gl.projects.list(membership=True, all=True)
         # Default to the authenticated user's username if no authors are provided.
         if authors is None:
@@ -17,11 +43,12 @@ class GitLabFetcher(BaseFetcher):
             self.authors = authors
 
     @property
-    def repos_names(self)->List[str]:
-        "to be implemented later"
+    def repos_names(self) -> List[str]:
+        """Return the list of repository names."""
         return [project.name for project in self.projects]
 
     def _filter_by_date(self, date_str: str) -> bool:
+        """Check if a date string is within the configured date range."""
         date_obj = datetime.fromisoformat(date_str)
         if self.start_date and date_obj < self.start_date:
             return False
@@ -30,12 +57,19 @@ class GitLabFetcher(BaseFetcher):
         return True
 
     def _stop_fetching(self, date_str: str) -> bool:
+        """Determine if fetching should stop based on the date string."""
         date_obj = datetime.fromisoformat(date_str)
         if self.start_date and date_obj < self.start_date:
             return True
         return False
 
     def fetch_commits(self) -> List[Dict[str, Any]]:
+        """
+        Fetch commits for all projects and authors.
+
+        Returns:
+            List[Dict[str, Any]]: List of commit entries.
+        """
         entries = []
         processed_commits = set()
         for project in self.projects:
@@ -63,6 +97,12 @@ class GitLabFetcher(BaseFetcher):
         return entries
 
     def fetch_pull_requests(self) -> List[Dict[str, Any]]:
+        """
+        Fetch merge requests (pull requests) and their associated commits for all projects and authors.
+
+        Returns:
+            List[Dict[str, Any]]: List of pull request and commit_from_pr entries.
+        """
         entries = []
         processed_pr_commits = set()
         for project in self.projects:
@@ -109,6 +149,12 @@ class GitLabFetcher(BaseFetcher):
         return entries
 
     def fetch_issues(self) -> List[Dict[str, Any]]:
+        """
+        Fetch issues assigned to the authenticated user for all projects.
+
+        Returns:
+            List[Dict[str, Any]]: List of issue entries.
+        """
         entries = []
         for project in self.projects:
             if self.repo_filter and project.name not in self.repo_filter:
@@ -126,4 +172,16 @@ class GitLabFetcher(BaseFetcher):
                     entries.append(entry)
                 if self._stop_fetching(issue_date):
                     break
-        return entries
+        return entries
+
+    def fetch_releases(self) -> List[Dict[str, Any]]:
+        """
+        Fetch releases for GitLab repositories.
+
+        Not implemented for GitLabFetcher.
+
+        Raises:
+            NotImplementedError: Always, since release fetching is not supported for GitLabFetcher.
+        """
+        # If GitLab release fetching is supported in the future, implement logic here.
+        raise NotImplementedError("Release fetching is not supported for GitLab (GitLabFetcher).")

{git_recap-0.1.3 → git_recap-0.1.4}/git_recap/providers/url_fetcher.py

@@ -11,14 +11,14 @@ from git_recap.providers.base_fetcher import BaseFetcher
 
 class URLFetcher(BaseFetcher):
     """Fetcher implementation for generic Git repository URLs."""
-    
+
     GIT_URL_PATTERN = re.compile(
         r'^(?:http|https|git|ssh)://'  # Protocol
         r'(?:\S+@)?'  # Optional username
         r'([^/]+)'  # Domain
         r'(?:[:/])([^/]+/[^/]+?)(?:\.git)?$'  # Repo path
     )
-    
+
     def __init__(
         self,
         url: str,
@@ -52,7 +52,7 @@ class URLFetcher(BaseFetcher):
         """Validate the Git repository URL using git ls-remote."""
         if not self.GIT_URL_PATTERN.match(self.url):
             raise ValueError(f"Invalid Git repository URL format: {self.url}")
-            
+
         try:
             result = subprocess.run(
                 ["git", "ls-remote", self.url],
@@ -80,7 +80,7 @@ class URLFetcher(BaseFetcher):
                 text=True,
                 timeout=300
             )
-            
+
             # Fetch all branches
             subprocess.run(
                 ["git", "-C", self.temp_dir, "fetch", "--all"],
@@ -89,7 +89,7 @@ class URLFetcher(BaseFetcher):
                 text=True,
                 timeout=300
             )
-            
+
             # Verify the cloned repository has at least one commit
             verify_result = subprocess.run(
                 ["git", "-C", self.temp_dir, "rev-list", "--count", "--all"],
@@ -99,7 +99,7 @@ class URLFetcher(BaseFetcher):
             )
             if int(verify_result.stdout.strip()) == 0:
                 raise ValueError("Cloned repository has no commits")
-                
+
         except subprocess.TimeoutExpired:
             raise RuntimeError("Repository cloning timed out")
         except subprocess.CalledProcessError as e:
@@ -113,23 +113,23 @@ class URLFetcher(BaseFetcher):
         """Return list of repository names (single item for URL fetcher)."""
         if not self.temp_dir:
             return []
-        
+
         match = self.GIT_URL_PATTERN.match(self.url)
         if not match:
             repo_name = self.url.split('/')[-1]
             return [repo_name]
-            
+
         repo_name = match.group(2).split('/')[-1]
         if repo_name.endswith(".git"):
             repo_name = repo_name[:-4]
-            
+
         return [repo_name]
 
     def _get_all_branches(self) -> List[str]:
         """Get list of all remote branches in the repository."""
         if not self.temp_dir:
             return []
-            
+
         try:
             result = subprocess.run(
                 ["git", "-C", self.temp_dir, "branch", "-r", "--format=%(refname:short)"],
@@ -187,11 +187,11 @@ class URLFetcher(BaseFetcher):
         for line in log_output.splitlines():
             if not line.strip():
                 continue
-                
+
             try:
                 sha, author, date_str, message = line.split("|", 3)
                 timestamp = datetime.fromisoformat(date_str)
-                
+
                 if self.start_date and timestamp < self.start_date:
                     continue
                 if self.end_date and timestamp > self.end_date:
@@ -207,7 +207,7 @@ class URLFetcher(BaseFetcher):
                 })
             except ValueError:
                 continue  # Skip malformed log entries
-                
+
         return entries
 
     def fetch_commits(self) -> List[Dict[str, Any]]:
@@ -222,6 +222,17 @@ class URLFetcher(BaseFetcher):
         """Fetch issues (not implemented for generic Git URLs)."""
         return []
 
+    def fetch_releases(self) -> List[Dict[str, Any]]:
+        """
+        Fetch releases for the repository.
+        Not implemented for generic Git URLs.
+        Raises:
+            NotImplementedError: Always, since release fetching is not supported for URLFetcher.
+        """
+        # If in the future, support for fetching releases from generic git repos is added,
+        # implement logic here (e.g., parse tags and annotate with metadata).
+        raise NotImplementedError("Release fetching is not supported for generic Git URLs (URLFetcher).")
+
     def clear(self) -> None:
         """Clean up temporary directory."""
         if self.temp_dir and os.path.exists(self.temp_dir):

git_recap-0.1.4/git_recap/utils.py

@@ -0,0 +1,147 @@
+from datetime import datetime
+from typing import List, Dict, Any
+from collections import defaultdict
+
+def parse_entries_to_txt(entries: List[Dict[str, Any]]) -> str:
+    """
+    Groups entries by day (YYYY-MM-DD) and produces a plain text summary.
+    
+    Each day's header is the date string, followed by bullet points that list:
+      - type (commit, commit_from_pr, pull_request, issue)
+      - repo name
+      - message text
+      - for pull requests: PR number or for commits from PR: pr_title
+    """
+    # Group entries by date (YYYY-MM-DD)
+    grouped = defaultdict(list)
+    for entry in entries:
+        ts = entry.get("timestamp")
+        # Convert timestamp to a datetime object if necessary
+        if isinstance(ts, str):
+            dt = datetime.fromisoformat(ts)
+        else:
+            dt = ts
+        day = dt.strftime("%Y-%m-%d")
+        grouped[day].append(entry)
+    
+    # Sort the days chronologically
+    sorted_days = sorted(grouped.keys())
+    
+    # Build the output text
+    lines = []
+    for day in sorted_days:
+        lines.append(day + ":")
+        # Optionally, sort the entries for that day if needed (e.g., by timestamp)
+        day_entries = sorted(grouped[day], key=lambda x: x["timestamp"])
+        for entry in day_entries:
+            typ = entry.get("type", "N/A")
+            repo = entry.get("repo", "N/A")
+            message = entry.get("message", "").strip()
+            # Build extra details for pull requests and commits from pull requests
+            extra = ""
+            if typ == "pull_request":
+                pr_number = entry.get("pr_number")
+                if pr_number is not None:
+                    extra = f" (PR #{pr_number})"
+            elif typ == "commit_from_pr":
+                pr_title = entry.get("pr_title", "")
+                if pr_title:
+                    extra = f" (PR: {pr_title})"
+            # Format the bullet point
+            bullet = f" - [{typ.replace('_', ' ').title()}] in {repo}: {message}{extra}"
+            lines.append(bullet)
+        lines.append("")  # blank line between days
+    
+    return "\n".join(lines)
+
+def parse_releases_to_txt(releases: List[Dict[str, Any]]) -> str:
+    """
+    Groups releases by day (YYYY-MM-DD, using published_at or created_at) and produces a plain text summary.
+
+    Each day's header is the date string, followed by a clear, LLM-friendly separator between releases:
+      - tag name and release name
+      - repo name
+      - author
+      - draft/prerelease status
+      - body/notes (if present)
+      - assets (if present)
+    """
+    grouped = defaultdict(list)
+    for rel in releases:
+        ts = rel.get("published_at") or rel.get("created_at")
+        if isinstance(ts, str):
+            dt = datetime.fromisoformat(ts)
+        else:
+            dt = ts
+        day = dt.strftime("%Y-%m-%d")
+        grouped[day].append(rel)
+
+    sorted_days = sorted(grouped.keys())
+
+    lines = []
+    for day in sorted_days:
+        lines.append(f"Date: {day}")
+        day_releases = sorted(grouped[day], key=lambda x: x.get("published_at") or x.get("created_at"))
+        for rel in day_releases:
+            lines.append("----- Release Start -----")
+            tag = rel.get("tag_name", "N/A")
+            name = rel.get("name", "")
+            repo = rel.get("repo", "N/A")
+            author = rel.get("author", "N/A")
+            draft = rel.get("draft", False)
+            prerelease = rel.get("prerelease", False)
+            body = rel.get("body", "")
+            assets = rel.get("assets", [])
+            
+            status = []
+            if draft:
+                status.append("draft")
+            if prerelease:
+                status.append("prerelease")
+            status_str = f" ({', '.join(status)})" if status else ""
+
+            lines.append(f"Release: {name}")
+            lines.append(f"Repository: {repo}")
+            lines.append(f"Tag: {tag}")
+            lines.append(f"Author: {author}")
+            if status_str:
+                lines.append(f"Status: {status_str.strip()}")
+            if body and body.strip():
+                lines.append(f"Notes: {body.strip()}")
+            if assets:
+                lines.append("Assets:")
+                for asset in assets:
+                    asset_name = asset.get("name", "N/A")
+                    asset_size = asset.get("size", "N/A")
+                    asset_url = asset.get("download_url", "")
+                    lines.append(f"  - {asset_name} ({asset_size} bytes){' - ' + asset_url if asset_url else ''}")
+            lines.append("----- Release End -----\n")  # clear end of release
+
+        lines.append("")  # blank line between days
+
+    return "\n".join(lines)
+
+
+# Example usage for releases:
+# if __name__ == "__main__":
+#     releases = [
+#         {
+#             "tag_name": "v1.0.0",
+#             "name": "Release 1.0.0",
+#             "repo": "test-repo",
+#             "author": "testuser",
+#             "published_at": "2025-03-15T10:00:00",
+#             "created_at": "2025-03-15T09:00:00",
+#             "draft": False,
+#             "prerelease": False,
+#             "body": "This is a test release",
+#             "assets": [
+#                 {
+#                     "name": "test-asset.zip",
+#                     "size": 1024,
+#                     "download_url": "https://github.com/test/releases/download/v1.0.0/test-asset.zip",
+#                 }
+#             ],
+#         }
+#     ]
+#     print(parse_releases_to_txt(releases))

{git_recap-0.1.3 → git_recap-0.1.4}/git_recap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-recap
-Version: 0.1.3
+Version: 0.1.4
 Summary: A modular Python tool that aggregates and formats user-authored messages from repositories.
 Author: Bruno V.
 Author-email: bruno.vitorino@tecnico.ulisboa.pt
@@ -21,8 +21,16 @@ Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 
+<a href="https://www.uneed.best/tool/gitrecap">
+  <img src="https://www.uneed.best/POTD2A.png" style="width: 250px;" alt="Uneed POTD2 Badge" />
+</a>
+
+---
+
 # Git Recap
 
+🎉 **Featured in Uneed's Latest Newsletter as a Staff Pick!** 🎉
+
 Git Recap is a modular Python tool that aggregates and formats user-authored messages from repositories hosted on GitHub, Azure DevOps, and GitLab. It fetches commit messages, pull requests (along with their associated commits), and issues, then consolidates and sorts these events into a clear, chronological summary. This summary is output as a plain text string that can serve as context for large language models or other analysis tools.
 
 ## Features

{git_recap-0.1.3 → git_recap-0.1.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="git-recap",
-    version="0.1.3",
+    version="0.1.4",
     packages=find_packages(),
     install_requires=[
         "PyGithub==2.6.1",

{git_recap-0.1.3 → git_recap-0.1.4}/tests/test_dummy_parser.py

@@ -47,6 +47,9 @@ class DummyFetcher(BaseFetcher):
     def repos_names(self):
         ...
 
+    def fetch_releases(self):
+        ...
+
 def test_get_authored_messages():
     # Create a dummy fetcher with a date range covering March 2025.
     fetcher = DummyFetcher(

git_recap-0.1.4/tests/test_parser.py

@@ -0,0 +1,237 @@
+import pytest
+from datetime import datetime
+from unittest.mock import Mock, patch
+from git_recap.utils import parse_entries_to_txt
+
+def test_parse_entries_to_txt():
+    # Example list of entries
+    entries = [
+        {
+            "type": "commit_from_pr",
+            "repo": "AiCore",
+            "message": "feat: update TODOs for ObservabilityDashboard",
+            "timestamp": "2025-03-14T00:17:02+00:00",
+            "sha": "dummysha1",
+            "pr_title": "Unified ai integration error monitoring"
+        },
+        {
+            "type": "commit",
+            "repo": "AiCore",
+            "message": "Merge pull request #5 from somebranch",
+            "timestamp": "2025-03-15T21:47:12+00:00",
+            "sha": "dummysha2"
+        },
+        {
+            "type": "pull_request",
+            "repo": "AiCore",
+            "message": "Unified ai integration error monitoring",
+            "timestamp": "2025-03-15T21:47:13+00:00",
+            "pr_number": 5
+        },
+        {
+            "type": "issue",
+            "repo": "AiCore",
+            "message": "Issue: error when launching app",
+            "timestamp": "2025-03-15T23:00:00+00:00",
+        },
+    ]
+    txt = parse_entries_to_txt(entries)
+    
+    # Check that day headers are present
+    assert "2025-03-14:" in txt
+    assert "2025-03-15:" in txt
+    
+    # Check that key message parts appear
+    assert "Feat: Update TodoS for Observabilitydashboard" in txt or "update TODOs" in txt
+    assert "Unified ai integration error monitoring" in txt
+    assert "Merge pull request" in txt
+    assert "Issue: error when launching app" in txt
+
+    # Check that individual timestamps and sha are not in the final output
+    assert "dummysha1" not in txt
+    assert "dummysha2" not in txt
+    assert "T00:17:02" not in txt  # individual timestamp should not be printed
+
+
+@patch('git_recap.providers.github_fetcher.Github')
+def test_fetch_releases_github(mock_github_class):
+    """
+    Unit test for GitHub release fetching functionality with proper mocking.
+    """
+    from git_recap.providers.github_fetcher import GitHubFetcher
+    
+    # Create mock objects
+    mock_github = Mock()
+    mock_user = Mock()
+    mock_repo = Mock()
+    mock_release = Mock()
+    mock_asset = Mock()
+    
+    # Configure the mock hierarchy
+    mock_github_class.return_value = mock_github
+    mock_github.get_user.return_value = mock_user
+    mock_user.login = "testuser"
+    mock_user.get_repos.return_value = [mock_repo]
+    
+    # Configure mock repo
+    mock_repo.name = "test-repo"
+    mock_repo.get_releases.return_value = [mock_release]
+    
+    # Configure mock release
+    mock_release.tag_name = "v1.0.0"
+    mock_release.name = "Release 1.0.0"
+    mock_release.title = "Release 1.0.0"  # Some releases use title instead of name
+    mock_release.author.login = "testuser"
+    mock_release.published_at = datetime(2025, 3, 15, 10, 0, 0)
+    mock_release.created_at = datetime(2025, 3, 15, 9, 0, 0)
+    mock_release.draft = False
+    mock_release.prerelease = False
+    mock_release.body = "This is a test release"
+    
+    # Configure mock asset
+    mock_asset.name = "test-asset.zip"
+    mock_asset.size = 1024
+    mock_asset.browser_download_url = "https://github.com/test/releases/download/v1.0.0/test-asset.zip"
+    mock_asset.content_type = "application/zip"
+    mock_asset.created_at = datetime(2025, 3, 15, 9, 30, 0)
+    mock_asset.updated_at = datetime(2025, 3, 15, 9, 30, 0)
+    
+    mock_release.get_assets.return_value = [mock_asset]
+    
+    # Create GitHubFetcher instance and test
+    fetcher = GitHubFetcher(pat="dummy_token")
+    releases = fetcher.fetch_releases()
+    
+    # Assertions
+    assert isinstance(releases, list)
+    assert len(releases) == 1
+    
+    release = releases[0]
+    assert release["tag_name"] == "v1.0.0"
+    assert release["name"] == "Release 1.0.0"
+    assert release["repo"] == "test-repo"
+    assert release["author"] == "testuser"
+    assert release["published_at"] == datetime(2025, 3, 15, 10, 0, 0)
+    assert release["created_at"] == datetime(2025, 3, 15, 9, 0, 0)
+    assert release["draft"] is False
+    assert release["prerelease"] is False
+    assert release["body"] == "This is a test release"
+    assert len(release["assets"]) == 1
+    
+    asset = release["assets"][0]
+    assert asset["name"] == "test-asset.zip"
+    assert asset["size"] == 1024
+    assert asset["download_url"] == "https://github.com/test/releases/download/v1.0.0/test-asset.zip"
+    assert asset["content_type"] == "application/zip"
+
+
+@patch('git_recap.providers.github_fetcher.Github')
+def test_fetch_releases_github_with_repo_filter(mock_github_class):
+    """
+    Test fetch_releases with repo_filter applied.
+    """
+    from git_recap.providers.github_fetcher import GitHubFetcher
+    
+    # Create mock objects
+    mock_github = Mock()
+    mock_user = Mock()
+    mock_repo1 = Mock()
+    mock_repo2 = Mock()
+    
+    # Configure the mock hierarchy
+    mock_github_class.return_value = mock_github
+    mock_github.get_user.return_value = mock_user
+    mock_user.login = "testuser"
+    mock_user.get_repos.return_value = [mock_repo1, mock_repo2]
+    
+    # Configure mock repos
+    mock_repo1.name = "allowed-repo"
+    mock_repo2.name = "filtered-repo"
+    mock_repo1.get_releases.return_value = []
+    mock_repo2.get_releases.return_value = []
+    
+    # Create GitHubFetcher instance with repo filter
+    fetcher = GitHubFetcher(pat="dummy_token", repo_filter=["allowed-repo"])
+    releases = fetcher.fetch_releases()
+    
+    # Assertions
+    assert isinstance(releases, list)
+    # Only allowed-repo should have been processed
+    mock_repo1.get_releases.assert_called_once()
+    mock_repo2.get_releases.assert_not_called()
+
+
+@patch('git_recap.providers.github_fetcher.Github')
+def test_fetch_releases_github_exception_handling(mock_github_class):
+    """
+    Test fetch_releases handles exceptions gracefully when a repo fails.
+    """
+    from git_recap.providers.github_fetcher import GitHubFetcher
+    
+    # Create mock objects
+    mock_github = Mock()
+    mock_user = Mock()
+    mock_repo1 = Mock()
+    mock_repo2 = Mock()
+    
+    # Configure the mock hierarchy
+    mock_github_class.return_value = mock_github
+    mock_github.get_user.return_value = mock_user
+    mock_user.login = "testuser"
+    mock_user.get_repos.return_value = [mock_repo1, mock_repo2]
+    
+    # Configure mock repos - one fails, one succeeds
+    mock_repo1.name = "failing-repo"
+    mock_repo2.name = "working-repo"
+    mock_repo1.get_releases.side_effect = Exception("Permission denied")
+    mock_repo2.get_releases.return_value = []
+    
+    # Create GitHubFetcher instance and test
+    fetcher = GitHubFetcher(pat="dummy_token")
+    releases = fetcher.fetch_releases()
+    
+    # Should return empty list and not raise exception
+    assert isinstance(releases, list)
+    assert len(releases) == 0
+
+
+def test_fetch_releases_not_implemented_providers():
+    """
+    Test that other providers raise NotImplementedError for releases.
+    """
+    from git_recap.providers.gitlab_fetcher import GitLabFetcher
+    from git_recap.providers.azure_fetcher import AzureFetcher
+    from git_recap.providers.url_fetcher import URLFetcher
+    
+    # These should raise NotImplementedError or similar
+    # Note: You may need to adjust this based on your actual implementation
+    
+    # GitLabFetcher test (assuming it doesn't implement fetch_releases yet)
+    try:
+        gitlab_fetcher = GitLabFetcher(pat="dummy", base_url="https://gitlab.com")
+        if hasattr(gitlab_fetcher, 'fetch_releases'):
+            with pytest.raises(NotImplementedError):
+                gitlab_fetcher.fetch_releases()
+    except Exception:
+        # If GitLabFetcher can't be instantiated with dummy data, that's fine
+        pass
+    
+    # AzureFetcher test (assuming it doesn't implement fetch_releases yet)
+    try:
+        azure_fetcher = AzureFetcher(pat="dummy", organization="test", project="test")
+        if hasattr(azure_fetcher, 'fetch_releases'):
+            with pytest.raises(NotImplementedError):
+                azure_fetcher.fetch_releases()
+    except Exception:
+        # If AzureFetcher can't be instantiated with dummy data, that's fine
+        pass
+    
+    # URLFetcher test (assuming it doesn't implement fetch_releases yet)
+    try:
+        url_fetcher = URLFetcher(pat="dummy", base_url="https://example.com")
+        if hasattr(url_fetcher, 'fetch_releases'):
+            with pytest.raises(NotImplementedError):
+                url_fetcher.fetch_releases()
+    except Exception:
+        # If URLFetcher can't be instantiated with dummy data, that's fine
+        pass

git_recap-0.1.3/git_recap/utils.py

@@ -1,93 +0,0 @@
-from datetime import datetime
-from typing import List, Dict, Any
-from collections import defaultdict
-
-def parse_entries_to_txt(entries: List[Dict[str, Any]]) -> str:
-    """
-    Groups entries by day (YYYY-MM-DD) and produces a plain text summary.
-    
-    Each day's header is the date string, followed by bullet points that list:
-      - type (commit, commit_from_pr, pull_request, issue)
-      - repo name
-      - message text
-      - for pull requests: PR number or for commits from PR: pr_title
-    """
-    # Group entries by date (YYYY-MM-DD)
-    grouped = defaultdict(list)
-    for entry in entries:
-        ts = entry.get("timestamp")
-        # Convert timestamp to a datetime object if necessary
-        if isinstance(ts, str):
-            dt = datetime.fromisoformat(ts)
-        else:
-            dt = ts
-        day = dt.strftime("%Y-%m-%d")
-        grouped[day].append(entry)
-    
-    # Sort the days chronologically
-    sorted_days = sorted(grouped.keys())
-    
-    # Build the output text
-    lines = []
-    for day in sorted_days:
-        lines.append(day + ":")
-        # Optionally, sort the entries for that day if needed (e.g., by timestamp)
-        day_entries = sorted(grouped[day], key=lambda x: x["timestamp"])
-        for entry in day_entries:
-            typ = entry.get("type", "N/A")
-            repo = entry.get("repo", "N/A")
-            message = entry.get("message", "").strip()
-            # Build extra details for pull requests and commits from pull requests
-            extra = ""
-            if typ == "pull_request":
-                pr_number = entry.get("pr_number")
-                if pr_number is not None:
-                    extra = f" (PR #{pr_number})"
-            elif typ == "commit_from_pr":
-                pr_title = entry.get("pr_title", "")
-                if pr_title:
-                    extra = f" (PR: {pr_title})"
-            # Format the bullet point
-            bullet = f" - [{typ.replace('_', ' ').title()}] in {repo}: {message}{extra}"
-            lines.append(bullet)
-        lines.append("")  # blank line between days
-    
-    return "\n".join(lines)
-
-# Example usage:
-if __name__ == "__main__":
-    # Assuming `output` is the list of dict entries from your fetcher.
-    output = [
-        {
-            "type": "commit_from_pr",
-            "repo": "AiCore",
-            "message": "feat: update TODOs for ObservabilityDashboard with new input/output tokens and cross workspace analysis",
-            "timestamp": "2025-03-14T00:17:02+00:00",
-            "sha": "d1f185f09e4fcb775374b9468755b8463c94a605",
-            "pr_title": "Unified ai integration error monitoring"
-        },
-        {
-            "type": "commit_from_pr",
-            "repo": "AiCore",
-            "message": "feat: enhance token usage visualization in ObservabilityDashboard with grouped bar chart",
-            "timestamp": "2025-03-15T00:20:15+00:00",
-            "sha": "875457b9c80076d821f36cc646ec354ef5124088",
-            "pr_title": "Unified ai integration error monitoring"
-        },
-        {
-            "type": "pull_request",
-            "repo": "AiCore",
-            "message": "Unified ai integration error monitoring",
-            "timestamp": "2025-03-15T21:47:13+00:00",
-            "pr_number": 5
-        },
-        {
-            "type": "commit",
-            "repo": "AiCore",
-            "message": "feat: update openai package version to 1.66.3 in requirements.txt and setup.py",
-            "timestamp": "2025-03-15T23:22:28+00:00",
-            "sha": "9f7e30ebcca8c909274dd8ca91fcfbd17bbf9195"
-        },
-    ]
-    context_txt = parse_entries_to_txt(output)
-    print(context_txt)

git_recap-0.1.3/tests/test_parser.py

@@ -1,52 +0,0 @@
-import pytest
-from datetime import datetime
-from git_recap.utils import parse_entries_to_txt  # assuming you placed the parser function in utils.py
-
-def test_parse_entries_to_txt():
-    # Example list of entries
-    entries = [
-        {
-            "type": "commit_from_pr",
-            "repo": "AiCore",
-            "message": "feat: update TODOs for ObservabilityDashboard",
-            "timestamp": "2025-03-14T00:17:02+00:00",
-            "sha": "dummysha1",
-            "pr_title": "Unified ai integration error monitoring"
-        },
-        {
-            "type": "commit",
-            "repo": "AiCore",
-            "message": "Merge pull request #5 from somebranch",
-            "timestamp": "2025-03-15T21:47:12+00:00",
-            "sha": "dummysha2"
-        },
-        {
-            "type": "pull_request",
-            "repo": "AiCore",
-            "message": "Unified ai integration error monitoring",
-            "timestamp": "2025-03-15T21:47:13+00:00",
-            "pr_number": 5
-        },
-        {
-            "type": "issue",
-            "repo": "AiCore",
-            "message": "Issue: error when launching app",
-            "timestamp": "2025-03-15T23:00:00+00:00",
-        },
-    ]
-    txt = parse_entries_to_txt(entries)
-    
-    # Check that day headers are present
-    assert "2025-03-14:" in txt
-    assert "2025-03-15:" in txt
-    
-    # Check that key message parts appear
-    assert "Feat: Update TodoS for Observabilitydashboard" in txt or "update TODOs" in txt
-    assert "Unified ai integration error monitoring" in txt
-    assert "Merge pull request" in txt
-    assert "Issue: error when launching app" in txt
-
-    # Check that individual timestamps and sha are not in the final output
-    assert "dummysha1" not in txt
-    assert "dummysha2" not in txt
-    assert "T00:17:02" not in txt  # individual timestamp should not be printed