Update app.py

app.py

@@ -1,90 +1,139 @@
 import os
 import hmac
 import hashlib
+import time
+import jwt
+import requests
+import tempfile
+import shutil
 from fastapi import FastAPI, Request, HTTPException, status
 from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
+from git import Repo
 
 # --- Configuration ---
-# It's crucial to load the secret from the environment for security
+load_dotenv()
 GITHUB_WEBHOOK_SECRET = os.getenv("GITHUB_WEBHOOK_SECRET")
+GITHUB_APP_ID = os.getenv("GITHUB_APP_ID")
+GITHUB_PRIVATE_KEY = os.getenv("GITHUB_PRIVATE_KEY")
+
+# In-memory storage for our repository data (for this simple version)
+# In a real app, you might use Redis or a database.
+repo_data_store = {}
+
+# --- GitHub App Authentication Logic ---
+
+def create_jwt(app_id, private_key):
+    """Creates a JSON Web Token to authenticate as a GitHub App."""
+    now = int(time.time())
+    payload = {
+        "iat": now,  # Issued at time
+        "exp": now + (10 * 60),  # Expiration time (10 minutes)
+        "iss": app_id,  # Issuer (your app's ID)
+    }
+    return jwt.encode(payload, private_key, algorithm="RS256")
+
+def get_installation_access_token(installation_id, app_id, private_key):
+    """Gets a temporary access token for a specific installation."""
+    app_jwt = create_jwt(app_id, private_key)
+    headers = {
+        "Authorization": f"Bearer {app_jwt}",
+        "Accept": "application/vnd.github.v3+json",
+    }
+    url = f"https://api.github.com/app/installations/{installation_id}/access_tokens"
+    response = requests.post(url, headers=headers)
+    response.raise_for_status()  # Raise an exception for bad status codes
+    return response.json()["token"]
+
+
+# --- Repository Management Logic ---
+
+def process_repository(repo_url, token, repo_full_name):
+    """Clones a repo, parses it, and stores the data."""
+    # Create a temporary directory to clone the repo into
+    temp_dir = tempfile.mkdtemp()
+    print(f"Cloning {repo_full_name} into {temp_dir}")
+    
+    try:
+        # Clone the repository using the installation token
+        # The token is embedded in the URL for authentication
+        clone_url = repo_url.replace("https://", f"https://x-access-token:{token}@")
+        Repo.clone_from(clone_url, temp_dir)
+
+        # --- THIS IS WHERE STEP 2.C and 2.D WILL GO ---
+        # For now, we'll just simulate processing
+        print(f"Parsing repository {repo_full_name}...")
+        # In the next step, we will add AST parsing and vectorization here.
+        
+        # Store some placeholder data
+        repo_data_store[repo_full_name] = {"status": "processed", "path": temp_dir}
+        print(f"Successfully processed and 'stored' data for {repo_full_name}")
 
-# --- FastAPI App Initialization ---
+    except Exception as e:
+        print(f"Failed to process repository {repo_full_name}: {e}")
+    # finally:
+        # In a real app, you would clean up the temp directory.
+        # For this step, we leave it to inspect if needed.
+        # shutil.rmtree(temp_dir)
+
+
+# --- FastAPI App ---
 app = FastAPI()
 
-# --- Helper Functions ---
 async def verify_signature(request: Request):
-    """Verify that the request is from GitHub."""
+    # (This function remains unchanged from Step 1)
     if not GITHUB_WEBHOOK_SECRET:
-        # This is a server-side configuration error.
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, 
-            detail="Webhook secret not configured."
-        )
-
-    # Get the signature from the headers
+        raise HTTPException(status_code=500, detail="Webhook secret not configured.")
     signature_header = request.headers.get("X-Hub-Signature-256")
     if not signature_header:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST, 
-            detail="X-Hub-Signature-256 header is missing."
-        )
-
-    # The signature is in the format "sha256=..."
+        raise HTTPException(status_code=400, detail="X-Hub-Signature-256 header is missing.")
     sha_name, signature = signature_header.split("=")
     if sha_name != "sha256":
-        raise HTTPException(
-            status_code=status.HTTP_501_NOT_IMPLEMENTED, 
-            detail="Only sha256 signatures are supported."
-        )
-
-    # Get the raw request body
+        raise HTTPException(status_code=501, detail="Only sha256 signatures are supported.")
     body = await request.body()
-
-    # Create our own signature
-    mac = hmac.new(
-        GITHUB_WEBHOOK_SECRET.encode("utf-8"),
-        msg=body,
-        digestmod=hashlib.sha256
-    )
-
-    # Compare the signatures
+    mac = hmac.new(GITHUB_WEBHOOK_SECRET.encode("utf-8"), msg=body, digestmod=hashlib.sha256)
     if not hmac.compare_digest(mac.hexdigest(), signature):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST, 
-            detail="Invalid signature."
-        )
+        raise HTTPException(status_code=400, detail="Invalid signature.")
 
-# --- API Endpoints ---
 @app.get("/")
 def read_root():
-    """A simple root endpoint to confirm the server is running."""
     return {"message": "Docu-Pilot server is alive!"}
 
-
 @app.post("/api/github/webhook")
 async def github_webhook(request: Request):
-    """
-    This endpoint receives webhook events from GitHub.
-    It first verifies the signature to ensure the request is authentic.
-    """
+    """Handles all incoming webhook events from GitHub."""
     await verify_signature(request)
     
-    # You can get the event type from the headers
     event_type = request.headers.get("X-GitHub-Event")
     payload = await request.json()
 
-    if event_type == "push":
-        # In future steps, we will process the push event here.
-        # For now, we'll just log it.
+    print(f"Received event: {event_type}")
+
+    # --- NEW: Handle Installation Event ---
+    if event_type == "installation" and payload.get("action") == "created":
+        installation_id = payload["installation"]["id"]
+        print(f"New installation created! ID: {installation_id}")
+        
+        # Get an access token for this installation
+        try:
+            token = get_installation_access_token(installation_id, GITHUB_APP_ID, GITHUB_PRIVATE_KEY)
+            
+            # Process all repositories this app was installed on
+            for repo in payload["repositories"]:
+                repo_full_name = repo["full_name"]
+                repo_url = repo["html_url"]
+                process_repository(repo_url, token, repo_full_name)
+                
+        except Exception as e:
+            print(f"Error during installation processing: {e}")
+            raise HTTPException(status_code=500, detail="Failed to process installation.")
+
+    elif event_type == "push":
         pusher = payload.get("pusher", {}).get("name")
         repo_name = payload.get("repository", {}).get("full_name")
         print(f"Received a push event from {pusher} on repo {repo_name}")
-        
+        # We will add logic here in Step 4
+
     elif event_type == "ping":
-        # GitHub sends a ping event when the webhook is first set up.
         print("Received ping event from GitHub!")
 
     return {"status": "ok"}