api_server.py

from fastapi import FastAPI, HTTPException, BackgroundTasks
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse
from pydantic import BaseModel
from typing import Optional, List, Dict
import os
import traceback
from datetime import datetime
from pathlib import Path

from agent_core import CodeSentinelAgent
from github_client import GitHubClient
from pr_scorer import PRScorer
from storage import StorageManager
from config import Config

app = FastAPI(title="CodeSentinel API", version="1.0.0")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

agent = CodeSentinelAgent()
github_client = GitHubClient()
pr_scorer = PRScorer()
storage = StorageManager()


class IssueToPRRequest(BaseModel):
    repo_url: str
    issue_text: str
    base_branch: str = "main"
    max_files: int = 10
    max_lines: int = 500


class PRRankingRequest(BaseModel):
    repo_url: str


class ConfigResponse(BaseModel):
    has_gemini_key: bool
    has_github_token: bool
    max_files: int
    max_lines: int
    whitelist_enabled: bool
    whitelisted_repos: int


@app.get("/api/health")
async def health_check():
    return {"status": "ok", "timestamp": datetime.now().isoformat()}


@app.get("/api/config")
async def get_config() -> ConfigResponse:
    summary = Config.get_summary()
    return ConfigResponse(**summary)


@app.get("/api/stats")
async def get_stats():
    recent_runs = storage.get_recent_runs(1000)
    completed = sum(1 for r in recent_runs if r.get('status') == 'completed')
    failed = sum(1 for r in recent_runs if r.get('status') == 'failed')
    
    return {
        "total_runs": len(recent_runs),
        "completed_runs": completed,
        "failed_runs": failed,
        "success_rate": (completed / len(recent_runs) * 100) if recent_runs else 0
    }


@app.post("/api/issue-to-pr")
async def create_pr_from_issue(request: IssueToPRRequest, background_tasks: BackgroundTasks):
    config_issues = Config.validate_config()
    if config_issues:
        raise HTTPException(status_code=400, detail={"errors": config_issues})
    
    try:
        result = agent.process_issue_to_pr(
            repo_url=request.repo_url,
            issue_text=request.issue_text,
            base_branch=request.base_branch,
            max_files=request.max_files,
            max_lines=request.max_lines
        )
        return result
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail={
                "error": str(e),
                "traceback": traceback.format_exc()
            }
        )


@app.post("/api/pr-ranking")
async def rank_pull_requests(request: PRRankingRequest):
    config_issues = Config.validate_config()
    if config_issues:
        raise HTTPException(status_code=400, detail={"errors": config_issues})
    
    try:
        repo_full_name = github_client.parse_repo_url(request.repo_url)
        
        pr_list = github_client.get_open_pull_requests(repo_full_name)
        
        if not pr_list:
            return {
                "repo": repo_full_name,
                "total_prs": 0,
                "analyzed_prs": 0,
                "rankings": [],
                "timestamp": datetime.now().isoformat()
            }
        
        diff_contents = {}
        for pr in pr_list[:Config.PR_FETCH_LIMIT]:
            diff = github_client.get_pr_diff(repo_full_name, pr['number'])
            diff_contents[pr['number']] = diff
        
        ranked_prs = pr_scorer.rank_prs(pr_list[:Config.PR_FETCH_LIMIT], diff_contents)
        
        ranking_data = {
            "repo": repo_full_name,
            "timestamp": datetime.now().isoformat(),
            "total_prs": len(pr_list),
            "analyzed_prs": len(ranked_prs),
            "rankings": ranked_prs,
            "top_recommendations": pr_scorer.get_top_recommendations(ranked_prs, Config.TOP_RECOMMENDATIONS)
        }
        
        storage.save_pr_ranking(repo_full_name, ranking_data)
        
        return ranking_data
    
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail={
                "error": str(e),
                "traceback": traceback.format_exc()
            }
        )


@app.get("/api/runs")
async def get_runs(limit: int = 20):
    runs = storage.get_recent_runs(limit)
    return {"runs": runs}


@app.get("/api/runs/{run_id}")
async def get_run_details(run_id: str):
    details = storage.load_run(run_id)
    if not details:
        raise HTTPException(status_code=404, detail="Run not found")
    return details


@app.get("/api/repos")
async def list_repos():
    return {
        "whitelisted_repos": Config.WHITELISTED_REPOS if Config.WHITELISTED_REPOS else [],
        "whitelist_enabled": len(Config.WHITELISTED_REPOS) > 0 if Config.WHITELISTED_REPOS else False
    }


build_dir = Path(__file__).parent / "client" / "dist"
if build_dir.exists():
    app.mount("/assets", StaticFiles(directory=str(build_dir / "assets")), name="assets")
    
    @app.get("/{full_path:path}")
    async def serve_react_app(full_path: str):
        if full_path.startswith("api/"):
            raise HTTPException(status_code=404)
        
        file_path = build_dir / full_path
        if file_path.exists() and file_path.is_file():
            return FileResponse(file_path)
        
        return FileResponse(build_dir / "index.html")


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)