main.py

import os, hmac, hashlib, json
from fastapi import FastAPI, Request, HTTPException, BackgroundTasks
from dotenv import load_dotenv
from core.debate import run_debate
from core.github import get_pr_diff, post_comment
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles

load_dotenv()

app = FastAPI(title="CodeCouncil", version="1.0.0")

WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET", "codecouncil123")

def verify_signature(payload: bytes, signature: str) -> bool:
    expected = "sha256=" + hmac.new(
        WEBHOOK_SECRET.encode(), payload, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

def process_pr(repo: str, pr_number: int):
    try:
        print(f"\n🔍 Fetching PR #{pr_number} from {repo}...")
        diff = get_pr_diff(repo, pr_number)
        
        if len(diff) > 8000:
            diff = diff[:8000]
            print("⚠️ Diff truncated to 8000 chars")
        
        print(f"📄 Diff fetched ({len(diff)} chars). Starting debate...")
        verdict = run_debate(diff)
        
        print("💬 Posting comment to GitHub...")
        success = post_comment(repo, pr_number, verdict)
        
        if success:
            print(f"✅ Comment posted to PR #{pr_number}")
        else:
            print(f"❌ Failed to post comment to PR #{pr_number}")
            
    except Exception as e:
        print(f"❌ Error processing PR #{pr_number}: {e}")

@app.get("/")
def health():
    return {
        "status": "CodeCouncil running",
        "version": "1.0.0",
        "agents": ["SecurityAuditor", "PerfEngineer", "CleanCodeReviewer", "TechLead"]
    }

@app.post("/webhook")
async def github_webhook(request: Request, background_tasks: BackgroundTasks):
    payload = await request.body()
    signature = request.headers.get("X-Hub-Signature-256", "")
    
    if not verify_signature(payload, signature):
        raise HTTPException(status_code=401, detail="Invalid signature")
    
    event = request.headers.get("X-GitHub-Event")
    data = json.loads(payload)

    if event == "pull_request" and data.get("action") in ["opened", "synchronize"]:
        repo = data["repository"]["full_name"]
        pr_number = data["pull_request"]["number"]
        pr_title = data["pull_request"]["title"]
        
        print(f"\n📥 PR received: #{pr_number} — {pr_title}")
        background_tasks.add_task(process_pr, repo, pr_number)
        
        return {
            "status": "processing",
            "pr": pr_number,
            "repo": repo,
            "message": "Debate started in background"
        }

    return {"status": "ignored", "event": event}

@app.post("/review")
async def manual_review(request: Request):
    data = await request.json()
    repo = data.get("repo")
    pr_number = data.get("pr_number")
    
    if not repo or not pr_number:
        raise HTTPException(status_code=400, detail="repo and pr_number required")
    
    diff = get_pr_diff(repo, pr_number)
    if len(diff) > 8000:
        diff = diff[:8000]
    
    verdict = run_debate(diff)
    post_comment(repo, pr_number, verdict)
    
    return verdict

@app.get("/dashboard", response_class=HTMLResponse)
async def dashboard():
    with open("frontend/index.html", "r", encoding="utf-8") as f:
        return f.read()

@app.post("/api/review")
async def api_review(request: Request):
    data = await request.json()
    repo = data.get("repo")
    pr_number = data.get("pr_number")
    
    if not repo or not pr_number:
        raise HTTPException(status_code=400, detail="repo and pr_number required")
    
    try:
        diff = get_pr_diff(repo, int(pr_number))
        if len(diff) > 8000:
            diff = diff[:8000]
        
        verdict = run_debate(diff)
        post_comment(repo, int(pr_number), verdict)
        return verdict
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))