Merge pull request #1 from ukzada/main

Initial commit: GitHub Profile AI Reviewer

.env.example

@@ -0,0 +1,4 @@
+GITHUB_TOKEN=
+LANGSMITH_API_KEY=
+APP_HOST=0.0.0.0
+APP_PORT=8000

.gitignore

@@ -29,4 +29,4 @@ Thumbs.db
 .txtconfig
 .txtignore
 PolyMentor.txt
-venv312/
+venv312/

Dockerfile

@@ -0,0 +1,9 @@
+FROM pytorch/pytorch:2.7.1-cuda12.6-cudnn9-runtime
+WORKDIR /app
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

app/__init__.py

@@ -0,0 +1 @@
+

app/ai/__init__.py

@@ -0,0 +1 @@
+

app/ai/embeddings.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from app.core.config import settings
+
+try:
+    import torch
+    from transformers import AutoModel, AutoTokenizer
+except Exception:
+    torch = None
+    AutoModel = None
+    AutoTokenizer = None
+
+
+class CodeEmbeddingService:
+    def __init__(self) -> None:
+        self._dim = settings.embedding_dim
+        self._ready = False
+        self._tokenizer = None
+        self._model = None
+
+        if AutoModel is not None and AutoTokenizer is not None:
+            try:
+                self._tokenizer = AutoTokenizer.from_pretrained(settings.codebert_model)
+                self._model = AutoModel.from_pretrained(settings.codebert_model)
+                self._model.eval()
+                self._ready = True
+            except Exception:
+                self._ready = False
+
+    @property
+    def ready(self) -> bool:
+        return self._ready
+
+    @property
+    def embedding_dim(self) -> int:
+        return self._dim
+
+    def embed_repository_signals(self, snippets: Iterable[str]) -> list[float]:
+        text = "\n".join(snippets).strip()
+        if not text:
+            return [0.0] * self._dim
+
+        if self._ready and torch is not None and self._tokenizer is not None and self._model is not None:
+            tokens = self._tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+            with torch.no_grad():
+                outputs = self._model(**tokens)
+            cls = outputs.last_hidden_state[:, 0, :].squeeze(0)
+            return cls.tolist()
+
+        vector = [0.0] * self._dim
+        for i, ch in enumerate(text):
+            vector[i % self._dim] += (ord(ch) % 31) / 31.0
+        norm = sum(abs(v) for v in vector) or 1.0
+        return [v / norm for v in vector]

app/ai/scoring.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+try:
+    import torch
+    import torch.nn as nn
+except Exception:
+    torch = None
+    nn = None
+
+
+if nn is not None:
+    class DeveloperScoringModel(nn.Module):
+        def __init__(self, input_dim: int = 768) -> None:
+            super().__init__()
+            self.encoder = nn.Sequential(
+                nn.Linear(input_dim, 256),
+                nn.ReLU(),
+                nn.Dropout(0.2),
+                nn.Linear(256, 128),
+                nn.ReLU(),
+            )
+            self.level_head = nn.Linear(128, 4)
+            self.hiring_head = nn.Linear(128, 1)
+
+        def forward(self, x):
+            feat = self.encoder(x)
+            level_logits = self.level_head(feat)
+            hiring = torch.sigmoid(self.hiring_head(feat)) * 100
+            return level_logits, hiring
+else:
+    class DeveloperScoringModel:  # type: ignore[no-redef]
+        def __init__(self, input_dim: int = 768) -> None:
+            self.input_dim = input_dim
+
+
+@dataclass
+class ScoreOutput:
+    level: str
+    confidence: float
+    hiring_score: int
+
+
+class ScoringEngine:
+    LEVELS = ["Junior", "Mid", "Senior", "Staff / Principal"]
+
+    def __init__(self, input_dim: int = 768) -> None:
+        self._model = DeveloperScoringModel(input_dim=input_dim)
+
+    def infer(self, embedding: list[float], activity_score: float, consistency_score: float) -> ScoreOutput:
+        if torch is None or nn is None or not isinstance(self._model, nn.Module):
+            return self._heuristic(activity_score, consistency_score)
+
+        x = torch.tensor([embedding], dtype=torch.float32)
+        self._model.eval()
+        with torch.no_grad():
+            level_logits, hiring = self._model(x)
+
+        probs = torch.softmax(level_logits[0], dim=-1)
+        level_idx = int(torch.argmax(probs).item())
+        base_hiring = int(round(float(hiring[0].item())))
+        blended_hiring = int(max(0, min(100, 0.6 * base_hiring + 0.4 * activity_score)))
+        confidence = float(probs[level_idx].item())
+        return ScoreOutput(level=self.LEVELS[level_idx], confidence=round(confidence, 2), hiring_score=blended_hiring)
+
+    def _heuristic(self, activity_score: float, consistency_score: float) -> ScoreOutput:
+        hiring = int(max(0, min(100, round(0.7 * activity_score + 0.3 * consistency_score))))
+        if hiring >= 90:
+            return ScoreOutput("Staff / Principal", 0.95, hiring)
+        if hiring >= 75:
+            return ScoreOutput("Senior", 0.90, hiring)
+        if hiring >= 55:
+            return ScoreOutput("Mid", 0.86, hiring)
+        return ScoreOutput("Junior", 0.82, hiring)

app/clients/__init__.py

@@ -0,0 +1 @@
+

app/clients/github_graphql.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+import json
+from pathlib import Path
+
+import httpx
+
+from app.clients.queries import ANALYZE_PROFILE_QUERY
+from app.core.config import settings
+
+
+class GitHubAPIError(RuntimeError):
+    pass
+
+
+class GitHubGraphQLClient:
+    async def analyze_user(self, username: str) -> dict[str, Any]:
+        # If token missing, use local sample so app can run offline for testing.
+        if not settings.github_token:
+            sample_path = Path(__file__).with_name("sample_user.json")
+            if sample_path.exists():
+                with sample_path.open("r", encoding="utf-8") as fh:
+                    return json.load(fh)
+            raise GitHubAPIError("Missing GITHUB_TOKEN in environment and no sample_user.json available.")
+
+        headers = {"Authorization": f"Bearer {settings.github_token}", "Accept": "application/vnd.github+json"}
+        payload = {"query": ANALYZE_PROFILE_QUERY, "variables": {"username": username}}
+
+        async with httpx.AsyncClient(timeout=settings.request_timeout_seconds) as client:
+            response = await client.post(settings.github_api_url, headers=headers, json=payload)
+
+        if response.status_code >= 400:
+            raise GitHubAPIError(f"GitHub API status={response.status_code}: {response.text}")
+
+        data = response.json()
+        if data.get("errors"):
+            raise GitHubAPIError(str(data["errors"]))
+        if data.get("data", {}).get("user") is None:
+            raise GitHubAPIError(f"GitHub user '{username}' not found.")
+
+        return data

app/clients/queries.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+ANALYZE_PROFILE_QUERY = """
+query AnalyzeProfile($username: String!) {
+  user(login: $username) {
+    login
+    name
+    bio
+    createdAt
+    followers { totalCount }
+    contributionsCollection {
+      totalCommitContributions
+      totalPullRequestContributions
+      contributionCalendar {
+        totalContributions
+        weeks {
+          contributionDays {
+            contributionCount
+            date
+          }
+        }
+      }
+    }
+    repositories(first: 20, orderBy: { field: STARGAZERS, direction: DESC }) {
+      nodes {
+        name
+        nameWithOwner
+        description
+        stargazerCount
+        forkCount
+        primaryLanguage { name }
+        languages(first: 5) {
+          edges {
+            size
+            node { name }
+          }
+        }
+        defaultBranchRef {
+          target {
+            ... on Commit {
+              history(first: 1) { totalCount }
+            }
+          }
+        }
+      }
+    }
+    pullRequests(first: 50, states: MERGED) { totalCount }
+  }
+}
+""".strip()

app/clients/sample_user.json

@@ -0,0 +1,24 @@
+{
+  "data": {
+    "user": {
+      "repositories": {
+        "nodes": [
+          {
+            "name": "demo-repo",
+            "description": "Example repo",
+            "primaryLanguage": {"name": "Python"},
+            "defaultBranchRef": {"target": {"history": {"totalCount": 42}}},
+            "languages": {"edges": [{"node": {"name": "Python"}, "size": 1000}]}
+          }
+        ]
+      },
+      "pullRequests": {"totalCount": 5},
+      "contributionsCollection": {
+        "contributionCalendar": {"totalContributions": 120, "weeks": [
+          {"contributionDays": [{"contributionCount": 0}, {"contributionCount": 1}, {"contributionCount": 1}, {"contributionCount": 0}, {"contributionCount": 2}, {"contributionCount": 3}, {"contributionCount": 0}]},
+          {"contributionDays": [{"contributionCount": 1}, {"contributionCount": 1}, {"contributionCount": 1}, {"contributionCount": 1}, {"contributionCount": 1}, {"contributionCount": 1}, {"contributionCount": 1}]}
+        ]}
+      }
+    }
+  }
+}

app/clients/streak.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from app.schemas import StreakData
+
+
+def compute_streak_from_calendar(weeks: list[dict]) -> StreakData:
+    daily: list[int] = []
+    for week in weeks:
+        for day in week.get("contributionDays", []):
+            daily.append(int(day.get("contributionCount", 0)))
+
+    current = 0
+    for v in reversed(daily):
+        if v > 0:
+            current += 1
+        else:
+            break
+
+    longest = 0
+    run = 0
+    for v in daily:
+        if v > 0:
+            run += 1
+            longest = max(longest, run)
+        else:
+            run = 0
+
+    return StreakData(current_streak=current, longest_streak=longest)

app/core/__init__.py

@@ -0,0 +1 @@
+

app/core/config.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    app_name: str = "GitHub Profile AI Reviewer"
+    app_version: str = "1.0.0"
+    app_host: str = "0.0.0.0"
+    app_port: int = 8000
+
+    github_token: str = Field(default="", alias="GITHUB_TOKEN")
+    github_api_url: str = "https://api.github.com/graphql"
+
+    codebert_model: str = "microsoft/codebert-base"
+    embedding_dim: int = 768
+    request_timeout_seconds: float = 30.0
+
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore", populate_by_name=True)
+
+
+settings = Settings()

app/core/logging.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+import logging
+
+
+def setup_logging() -> None:
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(name)s | %(message)s")

app/graph/__init__.py

@@ -0,0 +1 @@
+

app/graph/state.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any, TypedDict
+
+
+class ProfileState(TypedDict, total=False):
+    username: str
+    graphql_data: dict[str, Any]
+    language_embeddings: list[float]
+    feature_vector: list[float]
+    strongest_language: str
+    language_breakdown: dict[str, int]
+    total_commits: int
+    merged_prs: int
+    total_contributions: int
+    consistency_score: int
+    current_streak: int
+    longest_streak: int
+    developer_level: str
+    confidence: float
+    hiring_score: int
+    final_report: dict[str, Any]

app/graph/workflow.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any
+
+from app.ai.embeddings import CodeEmbeddingService
+from app.ai.scoring import ScoringEngine
+from app.clients.github_graphql import GitHubGraphQLClient
+from app.clients.streak import compute_streak_from_calendar
+from app.graph.state import ProfileState
+
+
+def _extract_features(user: dict[str, Any]) -> tuple[dict[str, int], int, int, int, list[str]]:
+    repositories = user.get("repositories", {}).get("nodes", [])
+    language_sizes: dict[str, int] = defaultdict(int)
+    repo_snippets: list[str] = []
+    total_commits = 0
+
+    for repo in repositories:
+        name = repo.get("name") or ""
+        desc = repo.get("description") or ""
+        primary = (repo.get("primaryLanguage") or {}).get("name") or ""
+        repo_snippets.append(f"repo:{name} lang:{primary} desc:{desc}")
+
+        default_branch = repo.get("defaultBranchRef") or {}
+        history = (default_branch.get("target") or {}).get("history", {})
+        total_commits += int(history.get("totalCount", 0))
+
+        for edge in repo.get("languages", {}).get("edges", []):
+            lang_name = edge.get("node", {}).get("name") or "Unknown"
+            language_sizes[lang_name] += int(edge.get("size", 0))
+
+    merged_prs = int(user.get("pullRequests", {}).get("totalCount", 0))
+    total_contributions = int(user.get("contributionsCollection", {}).get("contributionCalendar", {}).get("totalContributions", 0))
+    return dict(language_sizes), total_commits, merged_prs, total_contributions, repo_snippets
+
+
+def _normalize_activity(total_contributions: int, total_commits: int, merged_prs: int) -> int:
+    a = min(45, total_contributions // 20)
+    b = min(30, total_commits // 40)
+    c = min(25, merged_prs // 4)
+    return int(max(0, min(100, a + b + c)))
+
+
+def _language_breakdown(language_sizes: dict[str, int]) -> tuple[str, dict[str, int]]:
+    if not language_sizes:
+        return "Unknown", {}
+    strongest = max(language_sizes.items(), key=lambda x: x[1])[0]
+    total = sum(language_sizes.values()) or 1
+    breakdown = {lang: int((size / total) * 100) for lang, size in sorted(language_sizes.items(), key=lambda x: x[1], reverse=True)}
+    return strongest, breakdown
+
+
+class AnalyzerWorkflow:
+    def __init__(self) -> None:
+        self._github = GitHubGraphQLClient()
+        self._embedder = CodeEmbeddingService()
+        self._scorer = ScoringEngine(input_dim=self._embedder.embedding_dim)
+
+    async def run(self, username: str) -> ProfileState:
+        state: ProfileState = {"username": username}
+        raw = await self._github.analyze_user(username)
+        state["graphql_data"] = raw
+
+        user = raw["data"]["user"]
+        lang_sizes, total_commits, merged_prs, total_contributions, snippets = _extract_features(user)
+        strongest_language, breakdown = _language_breakdown(lang_sizes)
+
+        weeks = user.get("contributionsCollection", {}).get("contributionCalendar", {}).get("weeks", [])
+        streak = compute_streak_from_calendar(weeks)
+        consistency_score = int((streak.current_streak / streak.longest_streak) * 100) if streak.longest_streak > 0 else 0
+
+        embedding = self._embedder.embed_repository_signals(snippets)
+        activity_score = _normalize_activity(total_contributions, total_commits, merged_prs)
+        scored = self._scorer.infer(embedding, activity_score, consistency_score)
+
+        state["final_report"] = {
+            "username": username,
+            "developer_level": scored.level,
+            "confidence": scored.confidence,
+            "strongest_language": strongest_language,
+            "language_breakdown": breakdown,
+            "hiring_readiness_score": scored.hiring_score,
+            "consistency_score": consistency_score,
+            "graphql_signals": {
+                "total_commits": total_commits,
+                "merged_prs": merged_prs,
+                "total_contributions": total_contributions,
+            },
+            "streak_data": {
+                "current_streak": streak.current_streak,
+                "longest_streak": streak.longest_streak,
+            },
+            "model_info": {
+                "embedding_model": "microsoft/codebert-base",
+                "scoring_model": "DeveloperScoringModel",
+                "embedding_dim": self._embedder.embedding_dim,
+                "embedding_backend": "transformers" if self._embedder.ready else "deterministic-fallback",
+            },
+        }
+        return state

app/main.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from fastapi import FastAPI, HTTPException
+
+from app.clients.github_graphql import GitHubAPIError
+from app.core.config import settings
+from app.core.logging import setup_logging
+from app.schemas import AnalyzeRequest, AnalyzeResponse
+from app.service import AnalyzerService
+
+setup_logging()
+
+app = FastAPI(title=settings.app_name, version=settings.app_version)
+service: AnalyzerService | None = None
+
+
+def get_service() -> AnalyzerService:
+    global service
+    if service is None:
+        service = AnalyzerService()
+    return service
+
+
+@app.get("/health")
+async def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.post("/analyze", response_model=AnalyzeResponse)
+async def analyze(payload: AnalyzeRequest) -> AnalyzeResponse:
+    try:
+        return await get_service().analyze(payload.username)
+    except GitHubAPIError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc

app/schemas.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class AnalyzeRequest(BaseModel):
+    username: str = Field(min_length=1, max_length=39, pattern=r"^[A-Za-z0-9-]+$")
+
+
+class GraphQLSignals(BaseModel):
+    total_commits: int
+    merged_prs: int
+    total_contributions: int
+
+
+class StreakData(BaseModel):
+    current_streak: int
+    longest_streak: int
+
+
+class AnalyzeResponse(BaseModel):
+    username: str
+    developer_level: str
+    confidence: float
+    strongest_language: str
+    language_breakdown: dict[str, int]
+    hiring_readiness_score: int
+    consistency_score: int
+    graphql_signals: GraphQLSignals
+    streak_data: StreakData
+    model_info: dict[str, Any]

app/service.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from app.graph.workflow import AnalyzerWorkflow
+from app.schemas import AnalyzeResponse
+
+
+class AnalyzerService:
+    def __init__(self) -> None:
+        self._workflow = AnalyzerWorkflow()
+
+    async def analyze(self, username: str) -> AnalyzeResponse:
+        state = await self._workflow.run(username)
+        return AnalyzeResponse.model_validate(state["final_report"])

docker-compose.yml

@@ -0,0 +1,22 @@
+version: "3.9"
+services:
+  api:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - GITHUB_TOKEN=${GITHUB_TOKEN}
+      - LANGSMITH_API_KEY=${LANGSMITH_API_KEY}
+    volumes:
+      - hf_cache:/root/.cache/huggingface
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - capabilities: [gpu]
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+volumes:
+  hf_cache:

main.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+
+from app.service import AnalyzerService
+
+
+async def run(username: str) -> None:
+    service = AnalyzerService()
+    result = await service.analyze(username)
+    print(json.dumps(result.model_dump(), indent=2))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="GitHub Profile AI Reviewer CLI")
+    parser.add_argument("--username", required=True, help="GitHub username")
+    args = parser.parse_args()
+    asyncio.run(run(args.username))
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.115.12
+uvicorn[standard]==0.34.3
+httpx==0.28.1
+pydantic==2.11.5
+pydantic-settings==2.9.1
+python-dotenv==1.1.0
+langgraph==0.4.8
+transformers==4.52.4
+torch==2.7.1