Added function to get details for github repo from its url

functions/github.py

@@ -350,3 +350,386 @@ def format_repositories_for_llm(github_result: Dict) -> str:
     formatted_parts.append("\n=== END GITHUB REPOSITORIES ===")
 
     return '\n'.join(formatted_parts)
+
+
+def get_repository_details(repo_url: str) -> Dict:
+    """
+    Get detailed information about a specific GitHub repository.
+    
+    Args:
+        repo_url (str): GitHub repository URL (e.g., https://github.com/user/repo)
+        
+    Returns:
+        dict: Dictionary containing comprehensive repository information
+        
+    Example:
+        {
+            "status": "success",
+            "repository": {
+                "name": "repo-name",
+                "full_name": "user/repo-name",
+                "description": "Repository description",
+                "language": "Python",
+                "languages": {"Python": 85.5, "JavaScript": 14.5},
+                "stars": 100,
+                "forks": 25,
+                "watchers": 50,
+                "size": 1024,
+                "created_at": "2024-01-01T00:00:00Z",
+                "updated_at": "2024-01-15T00:00:00Z",
+                "pushed_at": "2024-01-15T00:00:00Z",
+                "html_url": "https://github.com/user/repo",
+                "clone_url": "https://github.com/user/repo.git",
+                "topics": ["python", "api", "web"],
+                "license": {"name": "MIT License", "spdx_id": "MIT"},
+                "readme": "README content here...",
+                "file_structure": ["src/", "tests/", "README.md", "setup.py"],
+                "releases": [{"tag_name": "v1.0.0", "name": "Release 1.0.0"}],
+                "contributors": [{"login": "user1", "contributions": 50}],
+                "is_fork": false,
+                "is_archived": false,
+                "is_private": false,
+                "default_branch": "main",
+                "open_issues": 5,
+                "has_issues": true,
+                "has_wiki": true,
+                "has_pages": false
+            },
+            "message": "Successfully retrieved repository details"
+        }
+    """
+    if not repo_url or not repo_url.strip():
+        return {"status": "error", "message": "No repository URL provided"}
+
+    try:
+        # Extract owner and repo name from URL
+        owner, repo_name = _extract_repo_info(repo_url)
+        
+        if not owner or not repo_name:
+            return {"status": "error", "message": "Invalid GitHub repository URL format"}
+
+        logger.info("Fetching detailed information for repository: %s/%s", owner, repo_name)
+
+        # Get basic repository information
+        repo_info = _get_repository_info(owner, repo_name)
+        if repo_info["status"] != "success":
+            return repo_info
+
+        repo_data = repo_info["data"]
+
+        # Get additional repository details
+        additional_data = {}
+        
+        # Get languages
+        languages_result = _get_repository_languages(owner, repo_name)
+        if languages_result["status"] == "success":
+            additional_data["languages"] = languages_result["data"]
+
+        # Get README content
+        readme_result = _get_repository_readme(owner, repo_name)
+        if readme_result["status"] == "success":
+            additional_data["readme"] = readme_result["data"]
+
+        # Get file structure (root directory)
+        file_structure_result = _get_repository_contents(owner, repo_name)
+        if file_structure_result["status"] == "success":
+            additional_data["file_structure"] = file_structure_result["data"]
+
+        # Get releases
+        releases_result = _get_repository_releases(owner, repo_name)
+        if releases_result["status"] == "success":
+            additional_data["releases"] = releases_result["data"]
+
+        # Get contributors
+        contributors_result = _get_repository_contributors(owner, repo_name)
+        if contributors_result["status"] == "success":
+            additional_data["contributors"] = contributors_result["data"]
+
+        # Combine all data
+        repository_details = {
+            "name": repo_data.get("name", ""),
+            "full_name": repo_data.get("full_name", ""),
+            "description": repo_data.get("description", ""),
+            "language": repo_data.get("language", ""),
+            "languages": additional_data.get("languages", {}),
+            "stars": repo_data.get("stargazers_count", 0),
+            "forks": repo_data.get("forks_count", 0),
+            "watchers": repo_data.get("watchers_count", 0),
+            "size": repo_data.get("size", 0),
+            "created_at": repo_data.get("created_at", ""),
+            "updated_at": repo_data.get("updated_at", ""),
+            "pushed_at": repo_data.get("pushed_at", ""),
+            "html_url": repo_data.get("html_url", ""),
+            "clone_url": repo_data.get("clone_url", ""),
+            "ssh_url": repo_data.get("ssh_url", ""),
+            "topics": repo_data.get("topics", []),
+            "license": repo_data.get("license", {}),
+            "readme": additional_data.get("readme", ""),
+            "file_structure": additional_data.get("file_structure", []),
+            "releases": additional_data.get("releases", []),
+            "contributors": additional_data.get("contributors", []),
+            "is_fork": repo_data.get("fork", False),
+            "is_archived": repo_data.get("archived", False),
+            "is_private": repo_data.get("private", False),
+            "default_branch": repo_data.get("default_branch", "main"),
+            "open_issues": repo_data.get("open_issues_count", 0),
+            "has_issues": repo_data.get("has_issues", False),
+            "has_wiki": repo_data.get("has_wiki", False),
+            "has_pages": repo_data.get("has_pages", False),
+            "has_projects": repo_data.get("has_projects", False),
+            "visibility": repo_data.get("visibility", "public")
+        }
+
+        result = {
+            "status": "success",
+            "repository": repository_details,
+            "message": f"Successfully retrieved details for {owner}/{repo_name}"
+        }
+
+        # Save results to JSON file
+        try:
+            data_dir = Path(__file__).parent.parent / "data"
+            data_dir.mkdir(exist_ok=True)
+
+            output_file = data_dir / f"repo_details_{owner}_{repo_name}.json"
+            with open(output_file, 'w', encoding='utf-8') as f:
+                json.dump(result, f, indent=2, ensure_ascii=False)
+
+            logger.info("Repository details saved to %s", output_file)
+        except Exception as save_error:
+            logger.warning("Failed to save repository details to file: %s", str(save_error))
+
+        return result
+
+    except Exception as e:
+        logger.error("Error retrieving repository details: %s", str(e))
+        return {
+            "status": "error",
+            "message": f"Failed to retrieve repository details: {str(e)}"
+        }
+
+
+def _extract_repo_info(repo_url: str) -> tuple:
+    """
+    Extract owner and repository name from GitHub repository URL.
+    
+    Args:
+        repo_url (str): GitHub repository URL
+        
+    Returns:
+        tuple: (owner, repo_name) if valid URL, (None, None) otherwise
+    """
+    try:
+        # Clean up the URL
+        url = repo_url.strip().rstrip('/')
+        
+        # Handle various GitHub repository URL formats
+        patterns = [
+            r'github\.com/([^/]+)/([^/]+)/?$',  # https://github.com/owner/repo
+            r'github\.com/([^/]+)/([^/]+)/.*',  # https://github.com/owner/repo/anything
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, url)
+            if match:
+                owner = match.group(1)
+                repo_name = match.group(2)
+                
+                # Remove .git suffix if present
+                if repo_name.endswith('.git'):
+                    repo_name = repo_name[:-4]
+                
+                # Validate format
+                if (re.match(r'^[a-zA-Z0-9\-_\.]+$', owner) and 
+                    re.match(r'^[a-zA-Z0-9\-_\.]+$', repo_name)):
+                    return owner, repo_name
+        
+        return None, None
+        
+    except Exception as e:
+        logger.warning("Error extracting repo info from URL %s: %s", repo_url, str(e))
+        return None, None
+
+
+def _get_repository_info(owner: str, repo_name: str) -> Dict:
+    """Get basic repository information from GitHub API."""
+    try:
+        url = f"https://api.github.com/repos/{owner}/{repo_name}"
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Resumate-App/1.0"
+        }
+        
+        response = requests.get(url, headers=headers, timeout=10)
+        
+        if response.status_code == 404:
+            return {"status": "error", "message": f"Repository '{owner}/{repo_name}' not found"}
+        elif response.status_code == 403:
+            return {"status": "error", "message": "GitHub API rate limit exceeded"}
+        elif response.status_code != 200:
+            return {"status": "error", "message": f"GitHub API error: {response.status_code}"}
+        
+        return {"status": "success", "data": response.json()}
+        
+    except requests.RequestException as e:
+        logger.error("Network error fetching repository info: %s", str(e))
+        return {"status": "error", "message": f"Network error: {str(e)}"}
+
+
+def _get_repository_languages(owner: str, repo_name: str) -> Dict:
+    """Get repository languages from GitHub API."""
+    try:
+        url = f"https://api.github.com/repos/{owner}/{repo_name}/languages"
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Resumate-App/1.0"
+        }
+        
+        response = requests.get(url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            # Convert byte counts to percentages
+            languages = response.json()
+            total_bytes = sum(languages.values())
+            
+            if total_bytes > 0:
+                language_percentages = {
+                    lang: round((bytes_count / total_bytes) * 100, 1)
+                    for lang, bytes_count in languages.items()
+                }
+                return {"status": "success", "data": language_percentages}
+            
+        return {"status": "error", "message": "Could not retrieve languages"}
+        
+    except Exception as e:
+        logger.warning("Error fetching repository languages: %s", str(e))
+        return {"status": "error", "message": str(e)}
+
+
+def _get_repository_readme(owner: str, repo_name: str) -> Dict:
+    """Get repository README content from GitHub API."""
+    try:
+        url = f"https://api.github.com/repos/{owner}/{repo_name}/readme"
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Resumate-App/1.0"
+        }
+        
+        response = requests.get(url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            readme_data = response.json()
+            
+            # Get the raw content URL and fetch it
+            download_url = readme_data.get("download_url")
+            if download_url:
+                content_response = requests.get(download_url, timeout=10)
+                if content_response.status_code == 200:
+                    return {"status": "success", "data": content_response.text}
+            
+        return {"status": "error", "message": "README not found"}
+        
+    except Exception as e:
+        logger.warning("Error fetching README: %s", str(e))
+        return {"status": "error", "message": str(e)}
+
+
+def _get_repository_contents(owner: str, repo_name: str, path: str = "") -> Dict:
+    """Get repository contents (file structure) from GitHub API."""
+    try:
+        url = f"https://api.github.com/repos/{owner}/{repo_name}/contents/{path}"
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Resumate-App/1.0"
+        }
+        
+        response = requests.get(url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            contents = response.json()
+            
+            # Extract file and directory names
+            file_structure = []
+            for item in contents:
+                name = item.get("name", "")
+                if item.get("type") == "dir":
+                    name += "/"
+                file_structure.append(name)
+            
+            # Sort with directories first
+            file_structure.sort(key=lambda x: (not x.endswith("/"), x.lower()))
+            
+            return {"status": "success", "data": file_structure}
+            
+        return {"status": "error", "message": "Could not retrieve file structure"}
+        
+    except Exception as e:
+        logger.warning("Error fetching repository contents: %s", str(e))
+        return {"status": "error", "message": str(e)}
+
+
+def _get_repository_releases(owner: str, repo_name: str) -> Dict:
+    """Get repository releases from GitHub API."""
+    try:
+        url = f"https://api.github.com/repos/{owner}/{repo_name}/releases"
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Resumate-App/1.0"
+        }
+        
+        response = requests.get(url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            releases = response.json()
+            
+            # Extract key release information
+            release_info = []
+            for release in releases[:10]:  # Limit to 10 most recent
+                release_info.append({
+                    "tag_name": release.get("tag_name", ""),
+                    "name": release.get("name", ""),
+                    "published_at": release.get("published_at", ""),
+                    "prerelease": release.get("prerelease", False),
+                    "draft": release.get("draft", False)
+                })
+            
+            return {"status": "success", "data": release_info}
+            
+        return {"status": "error", "message": "Could not retrieve releases"}
+        
+    except Exception as e:
+        logger.warning("Error fetching repository releases: %s", str(e))
+        return {"status": "error", "message": str(e)}
+
+
+def _get_repository_contributors(owner: str, repo_name: str) -> Dict:
+    """Get repository contributors from GitHub API."""
+    try:
+        url = f"https://api.github.com/repos/{owner}/{repo_name}/contributors"
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Resumate-App/1.0"
+        }
+        
+        response = requests.get(url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            contributors = response.json()
+            
+            # Extract key contributor information
+            contributor_info = []
+            for contributor in contributors[:20]:  # Limit to top 20 contributors
+                contributor_info.append({
+                    "login": contributor.get("login", ""),
+                    "contributions": contributor.get("contributions", 0),
+                    "html_url": contributor.get("html_url", ""),
+                    "type": contributor.get("type", "")
+                })
+            
+            return {"status": "success", "data": contributor_info}
+            
+        return {"status": "error", "message": "Could not retrieve contributors"}
+        
+    except Exception as e:
+        logger.warning("Error fetching repository contributors: %s", str(e))
+        return {"status": "error", "message": str(e)}

tests/test_github.py

@@ -7,10 +7,11 @@ from unittest.mock import patch, MagicMock
 import requests
 from functions import github
 
+# pylint: disable=protected-access
 
 class TestExtractGitHubUsername(unittest.TestCase):
     """Test cases for the _extract_github_username function."""
-    
+
     def test_valid_github_urls(self):
         """Test extraction from valid GitHub URLs."""
         test_cases = [
@@ -381,5 +382,278 @@ class TestFormatRepositoriesForLLM(unittest.TestCase):
         self.assertNotIn("repo-20", result)
 
 
+class TestGetRepositoryDetails(unittest.TestCase):
+    """Test cases for the get_repository_details function."""
+    
+    def test_invalid_repository_url(self):
+        """Test handling of invalid repository URLs."""
+        invalid_urls = [
+            "",
+            None,
+            "https://gitlab.com/user/repo",
+            "https://github.com/",
+            "https://github.com/user",
+            "not-a-url",
+        ]
+        
+        for url in invalid_urls:
+            with self.subTest(url=url):
+                result = github.get_repository_details(url)
+                self.assertEqual(result["status"], "error")
+                self.assertIn("message", result)
+    
+    @patch('functions.github._get_repository_info')
+    @patch('functions.github._extract_repo_info')
+    def test_repository_not_found(self, mock_extract, mock_get_info):
+        """Test handling of non-existent repository."""
+        mock_extract.return_value = ("user", "nonexistent-repo")
+        mock_get_info.return_value = {
+            "status": "error",
+            "message": "Repository 'user/nonexistent-repo' not found"
+        }
+        
+        result = github.get_repository_details("https://github.com/user/nonexistent-repo")
+        
+        self.assertEqual(result["status"], "error")
+        self.assertIn("not found", result["message"])
+    
+    @patch('functions.github._get_repository_contributors')
+    @patch('functions.github._get_repository_releases')
+    @patch('functions.github._get_repository_contents')
+    @patch('functions.github._get_repository_readme')
+    @patch('functions.github._get_repository_languages')
+    @patch('functions.github._get_repository_info')
+    @patch('functions.github._extract_repo_info')
+    def test_successful_repository_details(self, mock_extract, mock_get_info, 
+                                         mock_languages, mock_readme, mock_contents,
+                                         mock_releases, mock_contributors):
+        """Test successful repository details retrieval."""
+        # Mock URL extraction
+        mock_extract.return_value = ("octocat", "Hello-World")
+        
+        # Mock basic repository info
+        mock_get_info.return_value = {
+            "status": "success",
+            "data": {
+                "name": "Hello-World",
+                "full_name": "octocat/Hello-World",
+                "description": "This your first repo!",
+                "language": "C",
+                "stargazers_count": 80,
+                "forks_count": 9,
+                "watchers_count": 80,
+                "size": 108,
+                "created_at": "2011-01-26T19:01:12Z",
+                "updated_at": "2011-01-26T19:14:43Z",
+                "pushed_at": "2011-01-26T19:06:43Z",
+                "html_url": "https://github.com/octocat/Hello-World",
+                "clone_url": "https://github.com/octocat/Hello-World.git",
+                "ssh_url": "[email protected]:octocat/Hello-World.git",
+                "topics": ["example", "tutorial"],
+                "license": {"name": "MIT License", "spdx_id": "MIT"},
+                "fork": False,
+                "archived": False,
+                "private": False,
+                "default_branch": "master",
+                "open_issues_count": 0,
+                "has_issues": True,
+                "has_wiki": True,
+                "has_pages": False,
+                "has_projects": True,
+                "visibility": "public"
+            }
+        }
+        
+        # Mock additional data
+        mock_languages.return_value = {
+            "status": "success",
+            "data": {"C": 78.1, "Makefile": 21.9}
+        }
+        
+        mock_readme.return_value = {
+            "status": "success",
+            "data": "# Hello World\n\nThis is a test repository."
+        }
+        
+        mock_contents.return_value = {
+            "status": "success",
+            "data": ["README.md", "hello.c", "Makefile"]
+        }
+        
+        mock_releases.return_value = {
+            "status": "success",
+            "data": [
+                {
+                    "tag_name": "v1.0.0",
+                    "name": "First Release",
+                    "published_at": "2011-01-26T19:14:43Z",
+                    "prerelease": False,
+                    "draft": False
+                }
+            ]
+        }
+        
+        mock_contributors.return_value = {
+            "status": "success",
+            "data": [
+                {
+                    "login": "octocat",
+                    "contributions": 32,
+                    "html_url": "https://github.com/octocat",
+                    "type": "User"
+                }
+            ]
+        }
+        
+        result = github.get_repository_details("https://github.com/octocat/Hello-World")
+        
+        # Verify success
+        self.assertEqual(result["status"], "success")
+        self.assertIn("repository", result)
+        
+        repo = result["repository"]
+        
+        # Verify basic info
+        self.assertEqual(repo["name"], "Hello-World")
+        self.assertEqual(repo["full_name"], "octocat/Hello-World")
+        self.assertEqual(repo["description"], "This your first repo!")
+        self.assertEqual(repo["language"], "C")
+        self.assertEqual(repo["stars"], 80)
+        self.assertEqual(repo["forks"], 9)
+        
+        # Verify additional data
+        self.assertEqual(repo["languages"], {"C": 78.1, "Makefile": 21.9})
+        self.assertIn("Hello World", repo["readme"])
+        self.assertEqual(repo["file_structure"], ["README.md", "hello.c", "Makefile"])
+        self.assertEqual(len(repo["releases"]), 1)
+        self.assertEqual(repo["releases"][0]["tag_name"], "v1.0.0")
+        self.assertEqual(len(repo["contributors"]), 1)
+        self.assertEqual(repo["contributors"][0]["login"], "octocat")
+        
+        # Verify boolean flags
+        self.assertFalse(repo["is_fork"])
+        self.assertFalse(repo["is_archived"])
+        self.assertFalse(repo["is_private"])
+        self.assertTrue(repo["has_issues"])
+    
+    def test_extract_repo_info_valid_urls(self):
+        """Test _extract_repo_info with valid repository URLs."""
+        test_cases = [
+            ("https://github.com/octocat/Hello-World", ("octocat", "Hello-World")),
+            ("https://github.com/user/repo.git", ("user", "repo")),
+            ("https://github.com/org/project/", ("org", "project")),
+            ("github.com/test/example", ("test", "example")),
+            ("https://github.com/user/repo/issues", ("user", "repo")),
+        ]
+        
+        for url, expected in test_cases:
+            with self.subTest(url=url):
+                result = github._extract_repo_info(url)
+                self.assertEqual(result, expected)
+    
+    def test_extract_repo_info_invalid_urls(self):
+        """Test _extract_repo_info with invalid repository URLs."""
+        invalid_urls = [
+            "",
+            "https://gitlab.com/user/repo",
+            "https://github.com/user",
+            "https://github.com/",
+            "not-a-url",
+        ]
+        
+        for url in invalid_urls:
+            with self.subTest(url=url):
+                result = github._extract_repo_info(url)
+                self.assertEqual(result, (None, None))
+    
+    @patch('requests.get')
+    def test_get_repository_info_success(self, mock_get):
+        """Test _get_repository_info with successful response."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "name": "test-repo",
+            "full_name": "user/test-repo"
+        }
+        mock_get.return_value = mock_response
+        
+        result = github._get_repository_info("user", "test-repo")
+        
+        self.assertEqual(result["status"], "success")
+        self.assertIn("data", result)
+        self.assertEqual(result["data"]["name"], "test-repo")
+    
+    @patch('requests.get')
+    def test_get_repository_info_not_found(self, mock_get):
+        """Test _get_repository_info with 404 response."""
+        mock_response = MagicMock()
+        mock_response.status_code = 404
+        mock_get.return_value = mock_response
+        
+        result = github._get_repository_info("user", "nonexistent")
+        
+        self.assertEqual(result["status"], "error")
+        self.assertIn("not found", result["message"])
+    
+    @patch('requests.get')
+    def test_get_repository_languages_success(self, mock_get):
+        """Test _get_repository_languages with successful response."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "Python": 50000,
+            "JavaScript": 25000,
+            "CSS": 25000
+        }
+        mock_get.return_value = mock_response
+        
+        result = github._get_repository_languages("user", "repo")
+        
+        self.assertEqual(result["status"], "success")
+        expected_percentages = {"Python": 50.0, "JavaScript": 25.0, "CSS": 25.0}
+        self.assertEqual(result["data"], expected_percentages)
+    
+    @patch('requests.get')
+    def test_get_repository_readme_success(self, mock_get):
+        """Test _get_repository_readme with successful response."""
+        # Mock the README metadata response
+        readme_response = MagicMock()
+        readme_response.status_code = 200
+        readme_response.json.return_value = {
+            "download_url": "https://raw.githubusercontent.com/user/repo/main/README.md"
+        }
+        
+        # Mock the README content response
+        content_response = MagicMock()
+        content_response.status_code = 200
+        content_response.text = "# Test Repository\n\nThis is a test."
+        
+        mock_get.side_effect = [readme_response, content_response]
+        
+        result = github._get_repository_readme("user", "repo")
+        
+        self.assertEqual(result["status"], "success")
+        self.assertIn("Test Repository", result["data"])
+    
+    @patch('requests.get')
+    def test_get_repository_contents_success(self, mock_get):
+        """Test _get_repository_contents with successful response."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = [
+            {"name": "src", "type": "dir"},
+            {"name": "README.md", "type": "file"},
+            {"name": "setup.py", "type": "file"},
+            {"name": "tests", "type": "dir"}
+        ]
+        mock_get.return_value = mock_response
+        
+        result = github._get_repository_contents("user", "repo")
+        
+        self.assertEqual(result["status"], "success")
+        expected_structure = ["src/", "tests/", "README.md", "setup.py"]
+        self.assertEqual(result["data"], expected_structure)
+
+
 if __name__ == '__main__':
     unittest.main()