git-recap 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

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/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/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/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/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,
@@ -36,13 +36,13 @@ class URLFetcher(BaseFetcher):
         )
         self.url = self._normalize_url(url)
         self.temp_dir = None
-        self._validate_url()
+        # self._validate_url()
         self._clone_repo()
 
     def _normalize_url(self, url: str) -> str:
         """Normalize the Git URL to ensure consistent format."""
         url = url.strip()
-        if not url.endswith('.git'):
+        if not url.endswith('.git') and "_git" not in url:
             url += '.git'
         if not any(url.startswith(proto) for proto in ('http://', 'https://', 'git://', 'ssh://')):
             url = f'https://{url}'
@@ -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,22 +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:
-            return []
-            
+            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)"],
@@ -186,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:
@@ -206,7 +207,7 @@ class URLFetcher(BaseFetcher):
                 })
             except ValueError:
                 continue  # Skip malformed log entries
-                
+
         return entries
 
     def fetch_commits(self) -> List[Dict[str, Any]]:
@@ -221,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/utils.py

@@ -54,40 +54,94 @@ def parse_entries_to_txt(entries: List[Dict[str, Any]]) -> str:
     
     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)
+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.2.dist-info → git_recap-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-recap
-Version: 0.1.2
+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.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+git_recap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_recap/fetcher.py,sha256=oRlenzd9OsiBkCtpUgSZGlUoUnVpdkolUZhFOF1USBs,2677
+git_recap/utils.py,sha256=NAG0cvm1sYKEQD5E9PueduB3CZQRTahrioxZNgwwmi4,5481
+git_recap/providers/__init__.py,sha256=njrsu58KB60-wN78P0egm1lkQLIRq_PHLKM4WBt39Os,330
+git_recap/providers/azure_fetcher.py,sha256=nVJr77EYcuVDEAdY1B4UJCfHQTz8rE7s0Bmz3To1XVU,9722
+git_recap/providers/base_fetcher.py,sha256=EIkaqHBl5xyvNigK9jojlVxxbJrWXg0cNnRkmOLoPWk,4980
+git_recap/providers/github_fetcher.py,sha256=k9akil096PO29SNk2xaZPjRipnxS_sAO0GukWjMdSf4,7375
+git_recap/providers/gitlab_fetcher.py,sha256=apfaRrP7Dat0OKjo3InmNFwNEOiJShA8mSHPyW-9yKg,7333
+git_recap/providers/url_fetcher.py,sha256=oQqewY6uo-OgsCvZuodj6vWonHfeANrE-KSiCVH7il8,8741
+git_recap-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+git_recap-0.1.4.dist-info/METADATA,sha256=zC2u1gX9G2_VDmdFrJzE2nJykYfuztkHt9DxCgW6v9Q,4946
+git_recap-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+git_recap-0.1.4.dist-info/top_level.txt,sha256=1JUKd3WPB8c3LcD1deIW-1UTmYzA0zJqwugAz72YZ_o,10
+git_recap-0.1.4.dist-info/RECORD,,

{git_recap-0.1.2.dist-info → git_recap-0.1.4.dist-info}/WHEEL

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

git_recap-0.1.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-git_recap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-git_recap/fetcher.py,sha256=oRlenzd9OsiBkCtpUgSZGlUoUnVpdkolUZhFOF1USBs,2677
-git_recap/utils.py,sha256=mAGZ6bNklBmE-qpA6RG17_Bka8WRXzjLRAAGS9p3QXk,3646
-git_recap/providers/__init__.py,sha256=njrsu58KB60-wN78P0egm1lkQLIRq_PHLKM4WBt39Os,330
-git_recap/providers/azure_fetcher.py,sha256=PfPEeWTtx1Fqa1jClFPKqXhY5Yvs8MyEkSJkLAl4QvQ,7241
-git_recap/providers/base_fetcher.py,sha256=SS35FP8B9_RwnU6CnMbcV9g5_YRWp7v-S7pwbt402Ng,3067
-git_recap/providers/github_fetcher.py,sha256=rDb00RVy2NMpwv8s8Ry1-UjS6wf1Sh2Ndl0xKOZXMxU,4998
-git_recap/providers/gitlab_fetcher.py,sha256=ch1V9O-MPv5_nyg9yLs6EC9e-yqsFXBXMm6xVevWzuQ,5396
-git_recap/providers/url_fetcher.py,sha256=_4CGHfXt701GUHBjsWiu-2ZMTtNerwp60ZxTQh-Mwtc,8256
-git_recap-0.1.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-git_recap-0.1.2.dist-info/METADATA,sha256=USOwnxiUUkGbMt82rPVA2Dw0oAc-YqTl7ow-CvBKyaQ,4721
-git_recap-0.1.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-git_recap-0.1.2.dist-info/top_level.txt,sha256=1JUKd3WPB8c3LcD1deIW-1UTmYzA0zJqwugAz72YZ_o,10
-git_recap-0.1.2.dist-info/RECORD,,