feat: display accurate accessible repository counts for users and organizations

- Replace public_repos with accessible_repos count showing both public and private repos user has access to
- Fetch actual accessible repositories via GitHub API for accurate counts instead of relying on public_repos metadata
- Use /orgs/{org}/repos for organizations to include private repos with user access
- Use /user/repos with affiliation=owner,collaborator for user accounts to exclude org repos and prevent duplicates
- Add max_repos limit (200) to organizations list for improved performance when counting
- Add retry logic for GitHub API 502/503/504 server errors to improve resilience
- Configure structlog to respect LOG_LEVEL environment variable for better debugging
- Add detailed logging for repository access checks and permissions

Fixes issue where organizations showed "0 repos" despite user having access to repositories.
Resolves duplicate repositories appearing under both user account and organization listings.

Author: ascherj

dashboard/src/components/RepositoryManager.tsx

@@ -26,6 +26,7 @@ interface Organization {
   type: string; // "Organization" or "User"
   public_repos: number;
   total_private_repos?: number;
+  accessible_repos?: number;
 }
 
 interface OrganizationRepositories {
@@ -375,15 +376,15 @@ const RepositoryManager: React.FC = () => {
                           <span className="organization-type">({org.type})</span>
                         </h3>
                         <p className="organization-description">
-                          {org.description || `${org.public_repos} public repositories`}
+                          {org.description || `${org.accessible_repos ?? org.public_repos} accessible repositories`}
                         </p>
                       </div>
                     </div>
                     <div className="organization-expand">
                       <span className={`expand-arrow ${isExpanded ? 'expanded' : ''}`}>
                         ▶
                       </span>
-                      <span className="repo-count">{org.public_repos} repos</span>
+                      <span className="repo-count">{org.accessible_repos ?? org.public_repos} repos</span>
                     </div>
                   </div>
 

gateway/app.py

@@ -30,6 +30,14 @@
 from github_client import GitHubAPIClient, validate_public_repository, parse_github_url
 
 # Configure structured logging
+import logging
+
+# Set up Python's standard logging to respect LOG_LEVEL
+logging.basicConfig(
+    format="%(message)s",
+    level=os.getenv("LOG_LEVEL", "INFO"),
+)
+
 structlog.configure(
     processors=[
         structlog.stdlib.filter_by_level,
@@ -166,6 +174,7 @@ class OrganizationResponse(BaseModel):
     type: str  # "Organization" or "User"
     public_repos: int
     total_private_repos: Optional[int] = None
+    accessible_repos: Optional[int] = None
 
 
 class OrganizationRepositoriesResponse(BaseModel):
@@ -232,10 +241,10 @@ async def connect(self, websocket: WebSocket, user: Optional[dict] = None):
         await websocket.accept()
         self.active_connections[websocket] = user
         logger.info(
-            "Client connected", 
+            "Client connected",
             total_connections=len(self.active_connections),
             authenticated=user is not None,
-            user_id=user.get("sub") if user else None
+            user_id=user.get("sub") if user else None,
         )
 
     def disconnect(self, websocket: WebSocket):
@@ -307,7 +316,7 @@ async def health_check():
 async def websocket_endpoint(websocket: WebSocket, token: Optional[str] = None):
     """WebSocket endpoint for real-time updates with JWT authentication"""
     user = None
-    
+
     if token:
         try:
             user = verify_jwt_token(token)
@@ -318,7 +327,7 @@ async def websocket_endpoint(websocket: WebSocket, token: Optional[str] = None):
             return
     else:
         logger.info("WebSocket connection without authentication (public access)")
-    
+
     await manager.connect(websocket, user)
     try:
         while True:
@@ -349,9 +358,11 @@ async def get_public_repository_issues(
                 (owner, repo),
             )
             repo_row = cur.fetchone()
-            
+
             if not repo_row or not repo_row["is_public_dashboard"]:
-                raise HTTPException(status_code=404, detail="Public repository not found")
+                raise HTTPException(
+                    status_code=404, detail="Public repository not found"
+                )
 
             where_conditions = ["i.repository_owner = %s", "i.repository_name = %s"]
             params = [owner, repo]
@@ -410,7 +421,12 @@ async def get_public_repository_issues(
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("Error fetching public repository issues", owner=owner, repo=repo, error=str(e))
+        logger.error(
+            "Error fetching public repository issues",
+            owner=owner,
+            repo=repo,
+            error=str(e),
+        )
         raise HTTPException(status_code=500, detail="Failed to fetch issues")
 
 
@@ -506,7 +522,9 @@ async def get_issues(
 
 
 @app.get("/api/issues/{issue_id}", response_model=IssueResponse)
-async def get_issue(issue_id: int, current_user: Optional[dict] = Depends(get_current_user)):
+async def get_issue(
+    issue_id: int, current_user: Optional[dict] = Depends(get_current_user)
+):
     """Get a specific issue by ID (requires auth or public repo)"""
     try:
         conn = psycopg2.connect(DATABASE_URL)
@@ -535,7 +553,7 @@ async def get_issue(issue_id: int, current_user: Optional[dict] = Depends(get_cu
         is_public = row.get("is_public_dashboard", False)
         if not is_public and not current_user:
             raise HTTPException(status_code=401, detail="Authentication required")
-        
+
         if not is_public and current_user:
             user_id = current_user.get("sub")
             conn = psycopg2.connect(DATABASE_URL)
@@ -552,7 +570,7 @@ async def get_issue(issue_id: int, current_user: Optional[dict] = Depends(get_cu
                 )
                 has_access = cur.fetchone() is not None
             conn.close()
-            
+
             if not has_access:
                 raise HTTPException(status_code=403, detail="Access denied")
 
@@ -669,9 +687,11 @@ async def get_public_repository_stats(owner: str, repo: str):
                 (owner, repo),
             )
             repo_row = cur.fetchone()
-            
+
             if not repo_row or not repo_row["is_public_dashboard"]:
-                raise HTTPException(status_code=404, detail="Public repository not found")
+                raise HTTPException(
+                    status_code=404, detail="Public repository not found"
+                )
 
             cur.execute(
                 """
@@ -739,7 +759,12 @@ async def get_public_repository_stats(owner: str, repo: str):
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("Error fetching public repository stats", owner=owner, repo=repo, error=str(e))
+        logger.error(
+            "Error fetching public repository stats",
+            owner=owner,
+            repo=repo,
+            error=str(e),
+        )
         raise HTTPException(status_code=500, detail="Failed to fetch statistics")
 
 
@@ -1208,22 +1233,29 @@ async def get_user_organizations(
         async with GitHubAPIClient(github_token) as github_client:
             organizations = await github_client.get_user_organizations()
 
-        # Convert to response models
-        result = []
-        for org in organizations:
-            result.append(
-                OrganizationResponse(
-                    id=org.id,
-                    login=org.login,
-                    name=org.name,
-                    description=org.description,
-                    avatar_url=org.avatar_url,
-                    html_url=org.html_url,
-                    type=org.type,
-                    public_repos=org.public_repos,
-                    total_private_repos=org.total_private_repos,
+            # Fetch accessible repos count for each organization
+            result = []
+            for org in organizations:
+                # Get accessible repositories for this org to get accurate count
+                # Limit to 200 repos for performance (just for counting)
+                accessible_repos = await github_client.get_organization_repositories(
+                    org.login, max_repos=200
+                )
+
+                result.append(
+                    OrganizationResponse(
+                        id=org.id,
+                        login=org.login,
+                        name=org.name,
+                        description=org.description,
+                        avatar_url=org.avatar_url,
+                        html_url=org.html_url,
+                        type=org.type,
+                        public_repos=org.public_repos,
+                        total_private_repos=org.total_private_repos,
+                        accessible_repos=len(accessible_repos),
+                    )
                 )
-            )
 
         logger.info("Fetched user organizations", user_id=user_id, count=len(result))
         return result
@@ -1649,19 +1681,19 @@ async def _process_message(self, message):
             if "issue" in event_data:
                 repo_owner = event_data["issue"].get("repository_owner")
                 repo_name = event_data["issue"].get("repository_name")
-            
+
             # Create filter function for user access control
             def user_can_see_issue(user: Optional[Dict[str, Any]]) -> bool:
                 if user is None:
                     return False
-                
+
                 if not repo_owner or not repo_name:
                     return True
-                
+
                 user_id = user.get("sub")
                 if not user_id:
                     return False
-                
+
                 try:
                     conn = psycopg2.connect(DATABASE_URL)
                     with conn.cursor() as cur:
@@ -1686,7 +1718,9 @@ def user_can_see_issue(user: Optional[Dict[str, Any]]) -> bool:
                 f"DEBUG: Broadcasting to {len(self.manager.active_connections)} WebSocket clients with filtering"
             )
 
-            await self.manager.broadcast(json.dumps(websocket_message), user_filter=user_can_see_issue)
+            await self.manager.broadcast(
+                json.dumps(websocket_message), user_filter=user_can_see_issue
+            )
 
             print(f"DEBUG: Successfully broadcasted message from {message.topic}")
 
@@ -1695,7 +1729,9 @@ def user_can_see_issue(user: Optional[Dict[str, Any]]) -> bool:
                 topic=message.topic,
                 connected_clients=len(self.manager.active_connections),
                 message_type=websocket_message["type"],
-                repository=f"{repo_owner}/{repo_name}" if repo_owner and repo_name else None,
+                repository=f"{repo_owner}/{repo_name}"
+                if repo_owner and repo_name
+                else None,
             )
 
         except Exception as e:

gateway/github_client.py

@@ -53,6 +53,7 @@ class GitHubOrganization(BaseModel):
     type: str  # "Organization" or "User"
     public_repos: int
     total_private_repos: Optional[int] = None
+    accessible_repos: Optional[int] = None
 
 
 class GitHubAPIClient:
@@ -186,34 +187,62 @@ async def get_user_organizations(self) -> List[GitHubOrganization]:
         return organizations
 
     async def get_organization_repositories(
-        self, org_login: str, per_page: int = 100
+        self, org_login: str, per_page: int = 100, max_repos: Optional[int] = None
     ) -> List[Dict[str, Any]]:
         """Get repositories for a specific organization or user"""
         repositories = []
         page = 1
 
-        # Determine the endpoint based on whether this is a user or organization
-        # Try user repos first, then org repos if that fails
-        endpoints_to_try = [
-            f"{self.base_url}/users/{org_login}/repos",  # User repositories
-            f"{self.base_url}/orgs/{org_login}/repos",  # Organization repositories
-        ]
-
-        for endpoint in endpoints_to_try:
+        # Get current authenticated user to check if org_login is the user themselves
+        try:
+            user_response = await self.session.get(f"{self.base_url}/user")
+            user_response.raise_for_status()
+            current_user = user_response.json()
+            is_current_user = current_user["login"] == org_login
+        except Exception as e:
+            logger.error("Error fetching current user", error=str(e))
+            is_current_user = False
+
+        # Determine endpoints based on whether this is the current user or an org
+        if is_current_user:
+            # For the authenticated user, use /user/repos to get owned/collaborated repos only
+            # Exclude organization_member to avoid duplicates (orgs are listed separately)
+            endpoints_to_try = [
+                (
+                    f"{self.base_url}/user/repos",
+                    {"affiliation": "owner,collaborator"},
+                ),
+            ]
+        else:
+            # For organizations, try /orgs first (returns public + private with access)
+            # Then fall back to /users (returns public only)
+            endpoints_to_try = [
+                (f"{self.base_url}/orgs/{org_login}/repos", {}),
+                (f"{self.base_url}/users/{org_login}/repos", {}),
+            ]
+
+        for endpoint_config in endpoints_to_try:
+            endpoint = (
+                endpoint_config[0]
+                if isinstance(endpoint_config, tuple)
+                else endpoint_config
+            )
+            extra_params = (
+                endpoint_config[1] if isinstance(endpoint_config, tuple) else {}
+            )
             try:
                 page = 1
                 repositories = []
 
                 while True:
-                    response = await self.session.get(
-                        endpoint,
-                        params={
-                            "per_page": per_page,
-                            "page": page,
-                            "sort": "updated",
-                            "direction": "desc",
-                        },
-                    )
+                    params = {
+                        "per_page": per_page,
+                        "page": page,
+                        "sort": "updated",
+                        "direction": "desc",
+                        **extra_params,
+                    }
+                    response = await self.session.get(endpoint, params=params)
 
                     if response.status_code == 404:
                         # Try next endpoint
@@ -235,10 +264,32 @@ async def get_organization_repositories(
                             or permissions.get("push", False)
                             or permissions.get("admin", False)
                         ):
+                            logger.info(
+                                "User has access to repository",
+                                repo_name=repo.get("full_name"),
+                                endpoint=endpoint,
+                                permissions=repo.get("permissions", {}),
+                            )
                             accessible_repos.append(repo)
+                        else:
+                            logger.info(
+                                "User does not have access to repository",
+                                repo_name=repo.get("full_name"),
+                                permissions=repo.get("permissions", {}),
+                            )
 
                     repositories.extend(accessible_repos)
 
+                    # Check if we've hit the max_repos limit
+                    if max_repos and len(repositories) >= max_repos:
+                        logger.info(
+                            "Reached max_repos limit",
+                            org=org_login,
+                            max_repos=max_repos,
+                            fetched=len(repositories),
+                        )
+                        break
+
                     # Check rate limiting
                     remaining = int(response.headers.get("X-RateLimit-Remaining", 0))
                     if remaining < 10:
@@ -260,6 +311,15 @@ async def get_organization_repositories(
             except httpx.HTTPStatusError as e:
                 if e.response.status_code == 404:
                     continue  # Try next endpoint
+                elif e.response.status_code in [502, 503, 504]:
+                    # GitHub server errors - try fallback endpoint
+                    logger.warning(
+                        "GitHub server error, trying fallback endpoint",
+                        org=org_login,
+                        endpoint=endpoint,
+                        status=e.response.status_code,
+                    )
+                    continue
                 else:
                     logger.error(
                         "Error fetching organization repositories",