Update app.py

app.py

@@ -4,7 +4,7 @@ FastAPI server for GitHub App integration
 Connects desktop app to GitHub securely
 """
 
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from typing import Optional, List, Dict
@@ -12,6 +12,12 @@ import json
 import os
 from pathlib import Path
 from dotenv import load_dotenv
+from supabase import create_client, Client
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 from github_api import GitHubAppAuth, GitHubInsights, TokenManager
 
@@ -37,17 +43,30 @@ app.add_middleware(
 
 # Load environment variables
 APP_ID = os.getenv("GITHUB_APP_ID")
-PRIVATE_KEY = os.getenv("GITHUB_PRIVATE_KEY_PATH")
+PRIVATE_KEY_PATH = os.getenv("GITHUB_PRIVATE_KEY_PATH", "private-key.pem")
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_SECRET_KEY = os.getenv("SUPABASE_SECRET_KEY")
+DEFAULT_FIREBASE_ID = os.getenv("DEFAULT_FIREBASE_ID", "JDfZoVuGJhdLBEvR7rVCQKBG9r02")
 
 # Initialize GitHub App authentication
-if APP_ID and PRIVATE_KEY:
-    github_auth = GitHubAppAuth(APP_ID, PRIVATE_KEY)
+if APP_ID and os.path.exists(PRIVATE_KEY_PATH):
+    with open(PRIVATE_KEY_PATH, "r") as f:
+        private_key = f.read()
+    
+    github_auth = GitHubAppAuth(APP_ID, private_key)
     token_manager = TokenManager(github_auth)
 else:
     github_auth = None
     token_manager = None
     print("⚠️ WARNING: GitHub App credentials not configured")
 
+# Initialize Supabase client
+if SUPABASE_URL and SUPABASE_SECRET_KEY:
+    supabase: Optional[Client] = create_client(SUPABASE_URL, SUPABASE_SECRET_KEY)
+else:
+    supabase = None
+    print("⚠️ WARNING: Supabase credentials not configured")
+
 # Simple JSON storage for installations
 INSTALLATIONS_FILE = "installations.json"
 
@@ -65,6 +84,7 @@ class InstallationCallback(BaseModel):
 
 class InsightsRequest(BaseModel):
     """Request for repository insights from desktop app"""
+    firebase_id: str  # Now required
     org: str
     repo: str
 
@@ -74,6 +94,12 @@ class TokenRefreshRequest(BaseModel):
     installation_id: int
 
 
+class GitHubSyncRequest(BaseModel):
+    """Request to sync GitHub data into Supabase"""
+    firebase_id: str
+    org: str
+
+
 # ============================================================================
 # UTILITY FUNCTIONS
 # ============================================================================
@@ -108,6 +134,224 @@ def get_installation_id(org: str) -> Optional[int]:
     return None
 
 
+def ensure_user_exists(firebase_id: str):
+    if not supabase:
+        raise HTTPException(status_code=500, detail="Supabase not configured")
+
+    result = supabase.table("Users").select("firebase_id").eq("firebase_id", firebase_id).limit(1).execute()
+    if not result.data:
+        raise HTTPException(status_code=404, detail="User not found for firebase_id")
+
+
+def build_repo_rollup(org: str, repo: str, insights: GitHubInsights) -> Dict:
+    repo_info = insights.get_repository_info(org, repo)
+    commits = insights.get_commits(org, repo, per_page=100)
+    pull_requests = insights.get_pull_requests(org, repo, state="all")
+    issues = insights.get_issues(org, repo, state="all")
+    contributors = insights.get_contributors(org, repo)
+    languages = insights.get_languages(org, repo)
+
+    return {
+        "owner": repo_info.get("owner", {}).get("login"),
+        "repo": repo_info.get("name"),
+        "full_name": repo_info.get("full_name"),
+        "private": repo_info.get("private"),
+        "default_branch": repo_info.get("default_branch"),
+        "language": repo_info.get("language"),
+        "html_url": repo_info.get("html_url"),
+        "updated_at": repo_info.get("updated_at"),
+        "pushed_at": repo_info.get("pushed_at"),
+        "description": repo_info.get("description"),
+        "stars": repo_info.get("stargazers_count", 0),
+        "forks": repo_info.get("forks_count", 0),
+        "open_issues": repo_info.get("open_issues_count", 0),
+        "created_at": repo_info.get("created_at"),
+        "size_kb": repo_info.get("size", 0),
+        "commit_count": len(commits),
+        "pr_count": len(pull_requests),
+        "issue_count": len(issues),
+        "contributor_count": len(contributors),
+        "languages_json": languages,
+    }
+
+
+def sync_installation_to_supabase(firebase_id: str, org: str, installation_id: int) -> int:
+    if not github_auth:
+        logger.error("GitHub App not configured")
+        raise HTTPException(status_code=500, detail="GitHub App not configured")
+    if not supabase:
+        logger.error("Supabase not configured")
+        raise HTTPException(status_code=500, detail="Supabase not configured")
+
+    try:
+        logger.info(f"Starting sync for firebase_id={firebase_id}, org={org}, installation_id={installation_id}")
+        
+        # Check if user exists
+        logger.info(f"Checking if user exists with firebase_id={firebase_id}")
+        result = supabase.table("Users").select("firebase_id").eq("firebase_id", firebase_id).limit(1).execute()
+        if not result.data:
+            logger.error(f"User not found in Supabase for firebase_id={firebase_id}")
+            return 0
+
+        token = token_manager.get_token(installation_id)
+        repos = github_auth.get_installation_repositories(token)
+        logger.info(f"Found {len(repos)} repositories for {org}")
+        
+        insights = GitHubInsights(token)
+
+        # Build repo rollups
+        rows = []
+        for i, repo in enumerate(repos):
+            try:
+                repo_name = repo.get("name")
+                logger.info(f"Processing repo {i+1}/{len(repos)}: {repo_name}")
+                rollup = build_repo_rollup(org, repo_name, insights)
+                rollup["firebase_id"] = firebase_id
+                rollup["installation_id"] = installation_id
+                rows.append(rollup)
+            except Exception as e:
+                logger.warning(f"Failed to process repo {repo_name}: {str(e)}")
+                continue
+
+        if rows:
+            logger.info(f"Upserting {len(rows)} repos into github table")
+            supabase.table("github").upsert(rows, on_conflict="firebase_id,full_name").execute()
+            logger.info(f"Successfully synced {len(rows)} repos to github table")
+            
+            # Now sync detail data for each repo
+            for i, repo in enumerate(repos):
+                try:
+                    repo_name = repo.get("name")
+                    full_name = f"{org}/{repo_name}"
+                    logger.info(f"Syncing details for repo {i+1}/{len(repos)}: {repo_name}")
+                    
+                    # Get github_id
+                    github_result = supabase.table("github").select("id").eq("firebase_id", firebase_id).eq("full_name", full_name).limit(1).execute()
+                    if not github_result.data:
+                        logger.warning(f"Could not find {full_name} in github table, skipping details")
+                        continue
+                    
+                    github_id = github_result.data[0]["id"]
+                    
+                    # Sync commits
+                    try:
+                        commits = insights.get_commits(org, repo_name, per_page=100)
+                        commit_rows = []
+                        for commit in commits:
+                            commit_data = commit.get("commit", {})
+                            author_data = commit_data.get("author", {})
+                            commit_rows.append({
+                                "github_id": github_id,
+                                "firebase_id": firebase_id,
+                                "sha": commit.get("sha"),
+                                "message": commit_data.get("message"),
+                                "author": author_data.get("name"),
+                                "author_email": author_data.get("email"),
+                                "committed_date": author_data.get("date"),
+                            })
+                        if commit_rows:
+                            supabase.table("commits").upsert(commit_rows, on_conflict="firebase_id,sha").execute()
+                            logger.info(f"  Stored {len(commit_rows)} commits")
+                    except Exception as e:
+                        logger.warning(f"  Failed to sync commits: {str(e)}")
+                    
+                    # Sync issues
+                    try:
+                        issues = insights.get_issues(org, repo_name, state="all")
+                        issue_rows = []
+                        for issue in issues:
+                            if "pull_request" in issue:
+                                continue
+                            issue_rows.append({
+                                "github_id": github_id,
+                                "firebase_id": firebase_id,
+                                "issue_id": issue.get("id"),
+                                "issue_number": issue.get("number"),
+                                "title": issue.get("title"),
+                                "body": issue.get("body"),
+                                "state": issue.get("state"),
+                                "author": issue.get("user", {}).get("login"),
+                                "created_at": issue.get("created_at"),
+                                "updated_at": issue.get("updated_at"),
+                                "url": issue.get("html_url"),
+                                "labels": [label.get("name") for label in issue.get("labels", [])],
+                                "comments": issue.get("comments", 0),
+                                "reactions": issue.get("reactions", {}).get("total_count", 0),
+                            })
+                        if issue_rows:
+                            supabase.table("issues").upsert(issue_rows, on_conflict="firebase_id,issue_id").execute()
+                            logger.info(f"  Stored {len(issue_rows)} issues")
+                    except Exception as e:
+                        logger.warning(f"  Failed to sync issues: {str(e)}")
+                    
+                    # Sync pull requests
+                    try:
+                        prs = insights.get_pull_requests(org, repo_name, state="all")
+                        pr_rows = []
+                        for pr in prs:
+                            pr_rows.append({
+                                "github_id": github_id,
+                                "firebase_id": firebase_id,
+                                "pr_id": pr.get("id"),
+                                "pr_number": pr.get("number"),
+                                "title": pr.get("title"),
+                                "body": pr.get("body"),
+                                "state": pr.get("state"),
+                                "author": pr.get("user", {}).get("login"),
+                                "created_at": pr.get("created_at"),
+                                "updated_at": pr.get("updated_at"),
+                                "merged_at": pr.get("merged_at"),
+                                "closed_at": pr.get("closed_at"),
+                                "url": pr.get("html_url"),
+                                "head_branch": pr.get("head", {}).get("ref"),
+                                "base_branch": pr.get("base", {}).get("ref"),
+                                "draft": pr.get("draft", False),
+                                "mergeable": pr.get("mergeable"),
+                                "comments": pr.get("comments", 0),
+                                "commits": pr.get("commits", 0),
+                                "additions": pr.get("additions", 0),
+                                "deletions": pr.get("deletions", 0),
+                                "changed_files": pr.get("changed_files", 0),
+                            })
+                        if pr_rows:
+                            supabase.table("pull_requests").upsert(pr_rows, on_conflict="firebase_id,pr_id").execute()
+                            logger.info(f"  Stored {len(pr_rows)} pull requests")
+                    except Exception as e:
+                        logger.warning(f"  Failed to sync pull requests: {str(e)}")
+                    
+                    # Sync contributors
+                    try:
+                        contributors = insights.get_contributors(org, repo_name)
+                        contributor_rows = []
+                        for contributor in contributors:
+                            contributor_rows.append({
+                                "github_id": github_id,
+                                "firebase_id": firebase_id,
+                                "username": contributor.get("login"),
+                                "contributions": contributor.get("contributions", 0),
+                                "avatar_url": contributor.get("avatar_url"),
+                                "profile_url": contributor.get("html_url"),
+                            })
+                        if contributor_rows:
+                            supabase.table("contributors").upsert(contributor_rows, on_conflict="firebase_id,github_id,username").execute()
+                            logger.info(f"  Stored {len(contributor_rows)} contributors")
+                    except Exception as e:
+                        logger.warning(f"  Failed to sync contributors: {str(e)}")
+                    
+                except Exception as e:
+                    logger.warning(f"Failed to sync details for {repo_name}: {str(e)}")
+                    continue
+            
+            logger.info(f"Completed full sync for {len(rows)} repos")
+        else:
+            logger.warning("No repos to sync")
+
+        return len(rows)
+    except Exception as e:
+        logger.error(f"Sync failed: {str(e)}", exc_info=True)
+        return 0
+
+
 # ============================================================================
 # API ENDPOINTS
 # ============================================================================
@@ -133,18 +377,25 @@ def health_check():
 
 
 @app.get("/github/callback")
-async def github_callback(request: Request):
+async def github_callback(request: Request, background_tasks: BackgroundTasks):
     """
     Handle GitHub App installation callback
     
-    After org installs Codesage, GitHub redirects here with installation_id
-    This is the critical "make our product a member" step
+    After org installs Codesage, GitHub redirects here with installation_id and state (firebase_uid)
+    Frontend should redirect to: https://github.com/apps/{app_slug}/installations/new?state={firebase_uid}
+    GitHub redirects back with: /github/callback?installation_id=...&state={firebase_uid}
     """
     # Get query parameters
     query_params = dict(request.query_params)
     
     installation_id = query_params.get("installation_id")
     setup_action = query_params.get("setup_action")
+    firebase_id = query_params.get("state")  # GitHub passes firebase_uid via state parameter
+    
+    # Fallback to default if state not provided (for backward compatibility)
+    if not firebase_id:
+        logger.warning("No firebase_id in state parameter, using default")
+        firebase_id = DEFAULT_FIREBASE_ID
     
     if not installation_id:
         return {
@@ -184,11 +435,26 @@ async def github_callback(request: Request):
     # Save with org name if we got it, otherwise use placeholder
     if org_name:
         save_installation(org_name, installation_id)
+        sync_result = None
+        if supabase:
+            # Run heavy sync in background so callback returns immediately
+            background_tasks.add_task(
+                sync_installation_to_supabase,
+                firebase_id,  # Use firebase_id from state parameter
+                org_name,
+                installation_id
+            )
+            sync_result = {
+                "queued": True,
+                "firebase_id": firebase_id
+            }
+
         return {
             "success": True,
             "message": f"✅ Successfully installed Codesage for {org_name}",
             "org": org_name,
-            "installation_id": installation_id
+            "installation_id": installation_id,
+            "supabase_sync": sync_result
         }
     else:
         # Save with placeholder - user can update via /github/install
@@ -289,103 +555,287 @@ def list_org_repositories(org: str):
 @app.post("/insights/commits")
 def get_commits(data: InsightsRequest):
     """
-    Get commit history for a repository
-    Desktop app → Backend → GitHub
+    Get commit history for a repository and store in Supabase
+    firebase_id is required and will be passed in request body
     """
     if not github_auth:
         raise HTTPException(status_code=500, detail="GitHub App not configured")
+    if not supabase:
+        raise HTTPException(status_code=500, detail="Supabase not configured")
     
     installation_id = get_installation_id(data.org)
     if not installation_id:
         raise HTTPException(status_code=404, detail=f"No installation found for {data.org}")
     
     try:
+        # Fetch commits from GitHub
         token = token_manager.get_token(installation_id)
         insights = GitHubInsights(token)
-        commits = insights.get_commits(data.org, data.repo)
+        commits = insights.get_commits(data.org, data.repo, per_page=100)
+        
+        # Get github table id for this repo
+        full_name = f"{data.org}/{data.repo}"
+        github_result = supabase.table("github").select("id").eq("firebase_id", data.firebase_id).eq("full_name", full_name).limit(1).execute()
+        
+        if not github_result.data:
+            raise HTTPException(status_code=404, detail=f"Repo {full_name} not found in github table for this user")
+        
+        github_id = github_result.data[0]["id"]
+        
+        # Transform and store commits
+        commit_rows = []
+        for commit in commits:
+            commit_data = commit.get("commit", {})
+            author_data = commit_data.get("author", {})
+            
+            commit_rows.append({
+                "github_id": github_id,
+                "firebase_id": data.firebase_id,
+                "sha": commit.get("sha"),
+                "message": commit_data.get("message"),
+                "author": author_data.get("name"),
+                "author_email": author_data.get("email"),
+                "committed_date": author_data.get("date"),
+            })
+        
+        if commit_rows:
+            supabase.table("commits").upsert(commit_rows, on_conflict="firebase_id,sha").execute()
+            logger.info(f"Stored {len(commit_rows)} commits for {full_name}")
         
         return {
             "org": data.org,
             "repo": data.repo,
             "count": len(commits),
+            "stored": len(commit_rows),
             "commits": commits
         }
     except Exception as e:
+        logger.error(f"Failed to fetch/store commits: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Failed to fetch commits: {str(e)}")
 
 
 @app.post("/insights/pull-requests")
 def get_pull_requests(data: InsightsRequest):
-    """Get pull requests for a repository"""
+    """Get pull requests for a repository and store in Supabase
+    firebase_id is required and will be passed in request body
+    """
     if not github_auth:
         raise HTTPException(status_code=500, detail="GitHub App not configured")
+    if not supabase:
+        raise HTTPException(status_code=500, detail="Supabase not configured")
     
     installation_id = get_installation_id(data.org)
     if not installation_id:
         raise HTTPException(status_code=404, detail=f"No installation found for {data.org}")
     
     try:
+        # Fetch pull requests from GitHub
         token = token_manager.get_token(installation_id)
         insights = GitHubInsights(token)
-        prs = insights.get_pull_requests(data.org, data.repo)
+        prs = insights.get_pull_requests(data.org, data.repo, state="all")
+        
+        # Get github table id for this repo
+        full_name = f"{data.org}/{data.repo}"
+        github_result = supabase.table("github").select("id").eq("firebase_id", data.firebase_id).eq("full_name", full_name).limit(1).execute()
+        
+        if not github_result.data:
+            raise HTTPException(status_code=404, detail=f"Repo {full_name} not found in github table for this user")
+        
+        github_id = github_result.data[0]["id"]
+        
+        # Transform and store pull requests
+        pr_rows = []
+        for pr in prs:
+            pr_rows.append({
+                "github_id": github_id,
+                "firebase_id": data.firebase_id,
+                "pr_id": pr.get("id"),
+                "pr_number": pr.get("number"),
+                "title": pr.get("title"),
+                "body": pr.get("body"),
+                "state": pr.get("state"),
+                "author": pr.get("user", {}).get("login"),
+                "created_at": pr.get("created_at"),
+                "updated_at": pr.get("updated_at"),
+                "merged_at": pr.get("merged_at"),
+                "closed_at": pr.get("closed_at"),
+                "url": pr.get("html_url"),
+                "head_branch": pr.get("head", {}).get("ref"),
+                "base_branch": pr.get("base", {}).get("ref"),
+                "draft": pr.get("draft", False),
+                "mergeable": pr.get("mergeable"),
+                "comments": pr.get("comments", 0),
+                "commits": pr.get("commits", 0),
+                "additions": pr.get("additions", 0),
+                "deletions": pr.get("deletions", 0),
+                "changed_files": pr.get("changed_files", 0),
+            })
+        
+        if pr_rows:
+            supabase.table("pull_requests").upsert(pr_rows, on_conflict="firebase_id,pr_id").execute()
+            logger.info(f"Stored {len(pr_rows)} pull requests for {full_name}")
         
         return {
             "org": data.org,
             "repo": data.repo,
             "count": len(prs),
+            "stored": len(pr_rows),
             "pull_requests": prs
         }
     except Exception as e:
+        logger.error(f"Failed to fetch/store pull requests: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Failed to fetch pull requests: {str(e)}")
 
 
 @app.post("/insights/issues")
 def get_issues(data: InsightsRequest):
-    """Get issues for a repository"""
+    """Get issues for a repository and store in Supabase
+    firebase_id is required and will be passed in request body
+    """
     if not github_auth:
         raise HTTPException(status_code=500, detail="GitHub App not configured")
+    if not supabase:
+        raise HTTPException(status_code=500, detail="Supabase not configured")
     
     installation_id = get_installation_id(data.org)
     if not installation_id:
         raise HTTPException(status_code=404, detail=f"No installation found for {data.org}")
     
     try:
+        # Fetch issues from GitHub
         token = token_manager.get_token(installation_id)
         insights = GitHubInsights(token)
-        issues = insights.get_issues(data.org, data.repo)
+        issues = insights.get_issues(data.org, data.repo, state="all")
+        
+        # Get github table id for this repo
+        full_name = f"{data.org}/{data.repo}"
+        github_result = supabase.table("github").select("id").eq("firebase_id", data.firebase_id).eq("full_name", full_name).limit(1).execute()
+        
+        if not github_result.data:
+            raise HTTPException(status_code=404, detail=f"Repo {full_name} not found in github table for this user")
+        
+        github_id = github_result.data[0]["id"]
+        
+        # Transform and store issues
+        issue_rows = []
+        for issue in issues:
+            # Skip pull requests (they appear in issues API too)
+            if "pull_request" in issue:
+                continue
+                
+            issue_rows.append({
+                "github_id": github_id,
+                "firebase_id": data.firebase_id,
+                "issue_id": issue.get("id"),
+                "issue_number": issue.get("number"),
+                "title": issue.get("title"),
+                "body": issue.get("body"),
+                "state": issue.get("state"),
+                "author": issue.get("user", {}).get("login"),
+                "created_at": issue.get("created_at"),
+                "updated_at": issue.get("updated_at"),
+                "url": issue.get("html_url"),
+                "labels": [label.get("name") for label in issue.get("labels", [])],
+                "comments": issue.get("comments", 0),
+                "reactions": issue.get("reactions", {}).get("total_count", 0),
+            })
+        
+        if issue_rows:
+            supabase.table("issues").upsert(issue_rows, on_conflict="firebase_id,issue_id").execute()
+            logger.info(f"Stored {len(issue_rows)} issues for {full_name}")
         
         return {
             "org": data.org,
             "repo": data.repo,
             "count": len(issues),
+            "stored": len(issue_rows),
             "issues": issues
         }
     except Exception as e:
+        logger.error(f"Failed to fetch/store issues: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Failed to fetch issues: {str(e)}")
 
 
+@app.post("/github/sync")
+def sync_github_to_supabase(data: GitHubSyncRequest):
+    """
+    Sync GitHub repo data and rollup stats into Supabase
+    Trigger this after user creation with firebase_id
+    """
+    if not github_auth:
+        raise HTTPException(status_code=500, detail="GitHub App not configured")
+    if not supabase:
+        raise HTTPException(status_code=500, detail="Supabase not configured")
+
+    installation_id = get_installation_id(data.org)
+    if not installation_id:
+        raise HTTPException(status_code=404, detail=f"No installation found for {data.org}")
+
+    try:
+        synced = sync_installation_to_supabase(data.firebase_id, data.org, installation_id)
+        return {
+            "success": True,
+            "org": data.org,
+            "synced_repos": synced
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to sync GitHub data: {str(e)}")
+
+
 @app.post("/insights/contributors")
 def get_contributors(data: InsightsRequest):
-    """Get contributors and their stats"""
+    """Get contributors and their stats, store in Supabase
+    firebase_id is required and will be passed in request body
+    """
     if not github_auth:
         raise HTTPException(status_code=500, detail="GitHub App not configured")
+    if not supabase:
+        raise HTTPException(status_code=500, detail="Supabase not configured")
     
     installation_id = get_installation_id(data.org)
     if not installation_id:
         raise HTTPException(status_code=404, detail=f"No installation found for {data.org}")
     
     try:
+        # Fetch contributors from GitHub
         token = token_manager.get_token(installation_id)
         insights = GitHubInsights(token)
         contributors = insights.get_contributors(data.org, data.repo)
         
+        # Get github table id for this repo
+        full_name = f"{data.org}/{data.repo}"
+        github_result = supabase.table("github").select("id").eq("firebase_id", data.firebase_id).eq("full_name", full_name).limit(1).execute()
+        
+        if not github_result.data:
+            raise HTTPException(status_code=404, detail=f"Repo {full_name} not found in github table for this user")
+        
+        github_id = github_result.data[0]["id"]
+        
+        # Transform and store contributors
+        contributor_rows = []
+        for contributor in contributors:
+            contributor_rows.append({
+                "github_id": github_id,
+                "firebase_id": data.firebase_id,
+                "username": contributor.get("login"),
+                "contributions": contributor.get("contributions", 0),
+                "avatar_url": contributor.get("avatar_url"),
+                "profile_url": contributor.get("html_url"),
+            })
+        
+        if contributor_rows:
+            supabase.table("contributors").upsert(contributor_rows, on_conflict="firebase_id,github_id,username").execute()
+            logger.info(f"Stored {len(contributor_rows)} contributors for {full_name}")
+        
         return {
             "org": data.org,
             "repo": data.repo,
             "count": len(contributors),
+            "stored": len(contributor_rows),
             "contributors": contributors
         }
     except Exception as e:
+        logger.error(f"Failed to fetch/store contributors: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Failed to fetch contributors: {str(e)}")
 
 
@@ -445,11 +895,17 @@ def get_repository_activity(data: InsightsRequest):
         raise HTTPException(status_code=404, detail=f"No installation found for {data.org}")
     
     try:
+        logger.info(f"Fetching activity for {data.org}/{data.repo}")
         token = token_manager.get_token(installation_id)
         insights = GitHubInsights(token)
         
+        logger.info("Getting code frequency...")
         code_frequency = insights.get_code_frequency(data.org, data.repo)
+        logger.info(f"Code frequency returned: {len(code_frequency) if isinstance(code_frequency, list) else 'not a list'}")
+        
+        logger.info("Getting commit activity...")
         commit_activity = insights.get_commit_activity(data.org, data.repo)
+        logger.info(f"Commit activity returned: {len(commit_activity) if isinstance(commit_activity, list) else 'not a list'}")
         
         return {
             "org": data.org,
@@ -458,12 +914,42 @@ def get_repository_activity(data: InsightsRequest):
             "commit_activity": commit_activity
         }
     except Exception as e:
+        logger.error(f"Failed to fetch activity: {str(e)}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Failed to fetch activity: {str(e)}")
 
 
-# ============================================================================
-# RUN SERVER
-# ============================================================================
+@app.post("/github/sync/test")
+def test_sync(data: GitHubSyncRequest):
+    """
+    Test endpoint to debug sync issues
+    Shows what's happening without background task
+    """
+    logger.info(f"Test sync called for firebase_id={data.firebase_id}, org={data.org}")
+    
+    installation_id = get_installation_id(data.org)
+    if not installation_id:
+        return {
+            "success": False,
+            "error": f"No installation found for {data.org}",
+            "available_orgs": list(load_installations().keys())
+        }
+
+    try:
+        synced = sync_installation_to_supabase(data.firebase_id, data.org, installation_id)
+        return {
+            "success": True,
+            "org": data.org,
+            "firebase_id": data.firebase_id,
+            "synced_repos": synced
+        }
+    except Exception as e:
+        logger.error(f"Test sync failed: {str(e)}", exc_info=True)
+        return {
+            "success": False,
+            "error": str(e),
+            "org": data.org,
+            "firebase_id": data.firebase_id
+        }