fixed much

.env.example

@@ -1,4 +1,9 @@
 GITHUB_TOKEN=
+GITHUB_API_URL=https://api.github.com/graphql
+GITHUB_REST_API_URL=https://api.github.com
+GITHUB_PUBLIC_REPO_LIMIT=30
+GITHUB_FETCH_COMMIT_COUNTS=true
 LANGSMITH_API_KEY=
 APP_HOST=0.0.0.0
 APP_PORT=8000
+SCORING_BACKEND=heuristic

README.md

@@ -1,13 +1,57 @@
-# AI Pipeline Research & GraphQL Exploration Prototype
+# GitHub Profile AI Reviewer
 
-This repository contains the local prototype deliverables for the AI Pipeline research task, focusing on local CodeBERT embedding generation and GitHub GraphQL schema validation.
+FastAPI service that rates a public GitHub user profile out of 100.
 
----
+The API accepts a GitHub username and returns a `rating_score`, developer level, language breakdown, contribution signals, streak data, and model metadata.
 
-## 🛠️ Local Environment & Pipeline Setup
+## Token Behavior
 
-1. **Virtual Environment Configuration:**
-   Managed dependencies using a isolated local environment:
-   ```cmd
-   python -m venv venv
-   venv\Scripts\activate
+`GITHUB_TOKEN` is optional.
+
+When `GITHUB_TOKEN` is set, the service uses GitHub GraphQL for richer profile and contribution data. When it is empty, users can still rate any public GitHub username through GitHub's public REST API. Public REST mode is limited by GitHub's unauthenticated rate limits and cannot see private contribution data.
+
+## Environment
+
+Copy `.env.example` to `.env` and adjust only what you need:
+
+```env
+GITHUB_TOKEN=
+GITHUB_API_URL=https://api.github.com/graphql
+GITHUB_REST_API_URL=https://api.github.com
+GITHUB_PUBLIC_REPO_LIMIT=30
+GITHUB_FETCH_COMMIT_COUNTS=true
+APP_HOST=0.0.0.0
+APP_PORT=8000
+SCORING_BACKEND=heuristic
+```
+
+Keep `SCORING_BACKEND=heuristic` unless you have trained model weights. The neural backend is experimental.
+
+## Run Locally
+
+```bash
+pip install -r requirements.txt
+uvicorn app.main:app --host 0.0.0.0 --port 8000
+```
+
+Request a rating:
+
+```bash
+curl -X POST http://localhost:8000/analyze \
+  -H "Content-Type: application/json" \
+  -d '{"username":"octocat"}'
+```
+
+## Deploy With Docker
+
+```bash
+docker compose up --build -d
+```
+
+The API will be available on `http://localhost:${APP_PORT:-8000}`.
+
+## Response Fields
+
+- `rating_score`: main score from 0 to 100.
+- `hiring_readiness_score`: compatibility alias for the same 0 to 100 score.
+- `model_info.data_source`: `graphql` when a server token is configured, otherwise `rest-public`.

app/ai/scoring.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from app.core.config import settings
+
 try:
     import torch
     import torch.nn as nn
@@ -49,7 +51,7 @@ class ScoringEngine:
         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):
+        if settings.scoring_backend.lower() != "neural" or 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)

app/clients/github_graphql.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
+from datetime import UTC, datetime, timedelta
 from typing import Any
-import json
-from pathlib import Path
 
 import httpx
 
@@ -14,21 +13,38 @@ class GitHubAPIError(RuntimeError):
     pass
 
 
+def _headers() -> dict[str, str]:
+    headers = {"Accept": "application/vnd.github+json"}
+    if settings.github_token:
+        headers["Authorization"] = f"Bearer {settings.github_token}"
+    return headers
+
+
+def _extract_total_count(response: httpx.Response, fallback: int) -> int:
+    link = response.headers.get("Link", "")
+    for part in link.split(","):
+        if 'rel="last"' not in part:
+            continue
+        marker = "page="
+        if marker not in part:
+            continue
+        value = part.split(marker, 1)[1].split("&", 1)[0].split(">", 1)[0]
+        try:
+            return int(value)
+        except ValueError:
+            return fallback
+    return fallback
+
+
 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.")
+            return await self._analyze_public_user(username)
 
-        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)
+            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}")
@@ -39,4 +55,138 @@ class GitHubGraphQLClient:
         if data.get("data", {}).get("user") is None:
             raise GitHubAPIError(f"GitHub user '{username}' not found.")
 
+        data["source"] = "graphql"
         return data
+
+    async def _analyze_public_user(self, username: str) -> dict[str, Any]:
+        base_url = settings.github_rest_api_url.rstrip("/")
+        async with httpx.AsyncClient(base_url=base_url, timeout=settings.request_timeout_seconds, headers=_headers()) as client:
+            user_response = await client.get(f"/users/{username}")
+            if user_response.status_code == 404:
+                raise GitHubAPIError(f"GitHub user '{username}' not found.")
+            if user_response.status_code >= 400:
+                raise GitHubAPIError(f"GitHub API status={user_response.status_code}: {user_response.text}")
+
+            repos_response = await client.get(
+                f"/users/{username}/repos",
+                params={
+                    "per_page": min(max(settings.github_public_repo_limit, 1), 100),
+                    "sort": "updated",
+                    "direction": "desc",
+                    "type": "owner",
+                },
+            )
+            if repos_response.status_code >= 400:
+                raise GitHubAPIError(f"GitHub API status={repos_response.status_code}: {repos_response.text}")
+
+            events_response = await client.get(f"/users/{username}/events/public", params={"per_page": 100})
+            events = events_response.json() if events_response.status_code < 400 else []
+
+            user = user_response.json()
+            repos = repos_response.json()
+            repo_nodes = await self._build_public_repositories(client, username, repos)
+            weeks = _weeks_from_events(events)
+
+        return {
+            "source": "rest-public",
+            "data": {
+                "user": {
+                    "login": user.get("login", username),
+                    "name": user.get("name"),
+                    "bio": user.get("bio"),
+                    "createdAt": user.get("created_at"),
+                    "followers": {"totalCount": int(user.get("followers") or 0)},
+                    "contributionsCollection": {
+                        "totalCommitContributions": sum(_event_commit_count(event) for event in events),
+                        "totalPullRequestContributions": sum(1 for event in events if event.get("type") == "PullRequestEvent"),
+                        "contributionCalendar": {
+                            "totalContributions": len(events),
+                            "weeks": weeks,
+                        },
+                    },
+                    "repositories": {"nodes": repo_nodes},
+                    "pullRequests": {"totalCount": sum(1 for event in events if event.get("type") == "PullRequestEvent")},
+                }
+            },
+        }
+
+    async def _build_public_repositories(self, client: httpx.AsyncClient, username: str, repos: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        nodes: list[dict[str, Any]] = []
+        for repo in repos:
+            owner = repo.get("owner", {}).get("login") or username
+            name = repo.get("name")
+            if not name:
+                continue
+
+            languages = await self._fetch_repo_languages(client, owner, name)
+            total_commits = await self._fetch_commit_count(client, owner, name, repo.get("default_branch"))
+            nodes.append(
+                {
+                    "name": name,
+                    "nameWithOwner": repo.get("full_name") or f"{owner}/{name}",
+                    "description": repo.get("description"),
+                    "stargazerCount": int(repo.get("stargazers_count") or 0),
+                    "forkCount": int(repo.get("forks_count") or 0),
+                    "primaryLanguage": {"name": repo.get("language")} if repo.get("language") else None,
+                    "languages": {
+                        "edges": [
+                            {"size": int(size), "node": {"name": language}}
+                            for language, size in sorted(languages.items(), key=lambda item: item[1], reverse=True)[:5]
+                        ]
+                    },
+                    "defaultBranchRef": {
+                        "target": {
+                            "history": {"totalCount": total_commits},
+                        }
+                    },
+                }
+            )
+        return nodes
+
+    async def _fetch_repo_languages(self, client: httpx.AsyncClient, owner: str, repo: str) -> dict[str, int]:
+        response = await client.get(f"/repos/{owner}/{repo}/languages")
+        if response.status_code >= 400:
+            return {}
+        return {str(language): int(size) for language, size in response.json().items()}
+
+    async def _fetch_commit_count(self, client: httpx.AsyncClient, owner: str, repo: str, branch: str | None) -> int:
+        if not settings.github_fetch_commit_counts:
+            return 0
+        params: dict[str, Any] = {"per_page": 1}
+        if branch:
+            params["sha"] = branch
+        response = await client.get(f"/repos/{owner}/{repo}/commits", params=params)
+        if response.status_code >= 400:
+            return 0
+        return _extract_total_count(response, len(response.json()))
+
+
+def _event_commit_count(event: dict[str, Any]) -> int:
+    if event.get("type") != "PushEvent":
+        return 0
+    return len(event.get("payload", {}).get("commits", []))
+
+
+def _weeks_from_events(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    today = datetime.now(UTC).date()
+    start = today - timedelta(days=55)
+    counts: dict[str, int] = {}
+    for event in events:
+        created_at = event.get("created_at")
+        if not created_at:
+            continue
+        try:
+            day = datetime.fromisoformat(created_at.replace("Z", "+00:00")).date()
+        except ValueError:
+            continue
+        if day >= start:
+            counts[day.isoformat()] = counts.get(day.isoformat(), 0) + 1
+
+    weeks: list[dict[str, Any]] = []
+    for offset in range(0, 56, 7):
+        days = []
+        for day_offset in range(7):
+            date = start + timedelta(days=offset + day_offset)
+            days.append({"date": date.isoformat(), "contributionCount": counts.get(date.isoformat(), 0)})
+        weeks.append({"contributionDays": days})
+    return weeks

app/core/config.py

@@ -12,9 +12,13 @@ class Settings(BaseSettings):
 
     github_token: str = Field(default="", alias="GITHUB_TOKEN")
     github_api_url: str = "https://api.github.com/graphql"
+    github_rest_api_url: str = "https://api.github.com"
+    github_public_repo_limit: int = 30
+    github_fetch_commit_counts: bool = True
 
     codebert_model: str = "microsoft/codebert-base"
     embedding_dim: int = 768
+    scoring_backend: str = "heuristic"
     request_timeout_seconds: float = 30.0
 
     model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore", populate_by_name=True)

app/graph/workflow.py

@@ -6,6 +6,7 @@ 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.core.config import settings
 from app.clients.streak import compute_streak_from_calendar
 from app.graph.state import ProfileState
 
@@ -76,6 +77,7 @@ class AnalyzerWorkflow:
 
         state["final_report"] = {
             "username": username,
+            "rating_score": scored.hiring_score,
             "developer_level": scored.level,
             "confidence": scored.confidence,
             "strongest_language": strongest_language,
@@ -93,9 +95,10 @@ class AnalyzerWorkflow:
             },
             "model_info": {
                 "embedding_model": "microsoft/codebert-base",
-                "scoring_model": "DeveloperScoringModel",
+                "scoring_model": settings.scoring_backend,
                 "embedding_dim": self._embedder.embedding_dim,
                 "embedding_backend": "transformers" if self._embedder.ready else "deterministic-fallback",
+                "data_source": raw.get("source", "graphql"),
             },
         }
         return state

app/schemas.py

@@ -22,12 +22,13 @@ class StreakData(BaseModel):
 
 class AnalyzeResponse(BaseModel):
     username: str
+    rating_score: int = Field(ge=0, le=100)
     developer_level: str
     confidence: float
     strongest_language: str
     language_breakdown: dict[str, int]
-    hiring_readiness_score: int
-    consistency_score: int
+    hiring_readiness_score: int = Field(ge=0, le=100)
+    consistency_score: int = Field(ge=0, le=100)
     graphql_signals: GraphQLSignals
     streak_data: StreakData
     model_info: dict[str, Any]

backend/graph/nodes/.gitkeep

@@ -1 +0,0 @@
-

backend/graph/nodes/github_node.py

@@ -1,84 +1,87 @@
-import requests
-
-def github_node(state: dict) -> dict:
-    """
-    LangGraph Node to fetch developer profile metrics from GitHub GraphQL API.
-    Accepts state containing 'username' and updates state with raw profile insights.
-    """
-    # 1. State se input username nikalna
-    username = state.get("username", "octocat")
-    print(f" [GitHub Node] Executing GraphQL query for user: {username}")
-
-    # 2. Configuration & Query Structure
-    GITHUB_TOKEN = state.get("github_token", "YOUR_GITHUB_TOKEN_HERE")
-    url = "https://api.github.com/graphql"
-    headers = {"Authorization": f"Bearer {GITHUB_TOKEN}"}
-
-    query = """
-    query($username: String!) {
-      user(login: $username) {
-        name
-        bio
-        repositories(first: 10, orderBy: {field: STARGAZERS, direction: DESC}) {
-          nodes {
-            name
-            stargazerCount
-            primaryLanguage {
-              name
-            }
-          }
-        }
-        contributionsCollection {
-          contributionCalendar {
-            totalContributions
-          }
-        }
-      }
-    }
-    """
-    variables = {"username": username}
-
-    # 3. Execution Logic
-    try:
-        response = requests.post(url, json={'query': query, 'variables': variables}, headers=headers)
-        
-        if response.status_code == 200:
-            raw_data = response.json()
-            # State update karna custom key ke sath
-            state["github_raw_data"] = raw_data.get("data", {})
-            state["github_status"] = "SUCCESS"
-            print(" [GitHub Node] Query executed successfully.")
-        elif response.status_code == 401:
-            # Structuring dynamic mock fallback for initial pipeline validation
-            state["github_raw_data"] = {
-                "user": {
-                    "name": f"Mock {username.capitalize()}",
-                    "bio": "Automated pipeline validation user context.",
-                    "repositories": {
-                        "nodes": [
-                            {"name": "ai-pipeline-core", "stargazerCount": 42, "primaryLanguage": {"name": "Python"}}
-                        ]
-                    },
-                    "contributionsCollection": {"contributionCalendar": {"totalContributions": 150}}
-                }
-            }
-            state["github_status"] = "UNAUTHORIZED_FALLBACK_VALIDATION_PASSED"
-            print("[GitHub Node] Unauthorized code 401: Injected validated mock structure for LangGraph system continuation.")
-        else:
-            state["github_status"] = f"ERROR_{response.status_code}"
-            state["github_raw_data"] = {}
-
-    except Exception as e:
-        state["github_status"] = f"CONNECTION_FAILED: {str(e)}"
-        state["github_raw_data"] = {}
-
-    # 4. Mandatory LangGraph output format: Return the updated state
-    return state
-
-
-# ---- Dynamic Dummy Execution Box for Verification ----
-if __name__ == "__main__":
-    initial_state = {"username": "test_user"}
-    print(" Testing GitHub Node locally with dummy state input...")
-    final_state = github_node(initial_state)
-    print(f" Final State Output Keys: {list(final_state.keys())}\n")
+import os
+import requests
+
+def github_node(state: dict) -> dict:
+    """
+    LangGraph Node to fetch developer profile metrics from GitHub GraphQL API.
+    Accepts state containing 'username' and updates state with raw profile insights.
+    """
+    # 1. State se input username nikalna
+    username = state.get("username", "octocat")
+    print(f" [GitHub Node] Executing GraphQL query for user: {username}")
+
+    # 2. Configuration & Query Structure
+    github_token = state.get("github_token") or os.getenv("GITHUB_TOKEN", "")
+    url = os.getenv("GITHUB_API_URL", "https://api.github.com/graphql")
+    headers = {"Accept": "application/vnd.github+json"}
+    if github_token:
+        headers["Authorization"] = f"Bearer {github_token}"
+
+    query = """
+    query($username: String!) {
+      user(login: $username) {
+        name
+        bio
+        repositories(first: 10, orderBy: {field: STARGAZERS, direction: DESC}) {
+          nodes {
+            name
+            stargazerCount
+            primaryLanguage {
+              name
+            }
+          }
+        }
+        contributionsCollection {
+          contributionCalendar {
+            totalContributions
+          }
+        }
+      }
+    }
+    """
+    variables = {"username": username}
+
+    # 3. Execution Logic
+    try:
+        response = requests.post(url, json={'query': query, 'variables': variables}, headers=headers)
+
+        if response.status_code == 200:
+            raw_data = response.json()
+            # State update karna custom key ke sath
+            state["github_raw_data"] = raw_data.get("data", {})
+            state["github_status"] = "SUCCESS"
+            print(" [GitHub Node] Query executed successfully.")
+        elif response.status_code == 401:
+            # Structuring dynamic mock fallback for initial pipeline validation
+            state["github_raw_data"] = {
+                "user": {
+                    "name": f"Mock {username.capitalize()}",
+                    "bio": "Automated pipeline validation user context.",
+                    "repositories": {
+                        "nodes": [
+                            {"name": "ai-pipeline-core", "stargazerCount": 42, "primaryLanguage": {"name": "Python"}}
+                        ]
+                    },
+                    "contributionsCollection": {"contributionCalendar": {"totalContributions": 150}}
+                }
+            }
+            state["github_status"] = "UNAUTHORIZED_FALLBACK_VALIDATION_PASSED"
+            print("[GitHub Node] Unauthorized code 401: Injected validated mock structure for LangGraph system continuation.")
+        else:
+            state["github_status"] = f"ERROR_{response.status_code}"
+            state["github_raw_data"] = {}
+
+    except Exception as e:
+        state["github_status"] = f"CONNECTION_FAILED: {str(e)}"
+        state["github_raw_data"] = {}
+
+    # 4. Mandatory LangGraph output format: Return the updated state
+    return state
+
+
+# ---- Dynamic Dummy Execution Box for Verification ----
+if __name__ == "__main__":
+    initial_state = {"username": "test_user"}
+    print(" Testing GitHub Node locally with dummy state input...")
+    final_state = github_node(initial_state)
+    print(f" Final State Output Keys: {list(final_state.keys())}\n")

docker-compose.yml

@@ -3,17 +3,19 @@ services:
   api:
     build: .
     ports:
-      - "8000:8000"
+      - "${APP_PORT:-8000}:8000"
     environment:
+      - APP_HOST=0.0.0.0
+      - APP_PORT=8000
       - GITHUB_TOKEN=${GITHUB_TOKEN}
+      - GITHUB_API_URL=${GITHUB_API_URL:-https://api.github.com/graphql}
+      - GITHUB_REST_API_URL=${GITHUB_REST_API_URL:-https://api.github.com}
+      - GITHUB_PUBLIC_REPO_LIMIT=${GITHUB_PUBLIC_REPO_LIMIT:-30}
+      - GITHUB_FETCH_COMMIT_COUNTS=${GITHUB_FETCH_COMMIT_COUNTS:-true}
       - LANGSMITH_API_KEY=${LANGSMITH_API_KEY}
+      - SCORING_BACKEND=${SCORING_BACKEND:-heuristic}
     volumes:
       - hf_cache:/root/.cache/huggingface
-    deploy:
-      resources:
-        reservations:
-          devices:
-            - capabilities: [gpu]
   redis:
     image: redis:7-alpine
     ports:

github_api.py

@@ -1,55 +1,57 @@
-import requests
-import json
-
-# 1. GitHub Token and Configuration
-GITHUB_TOKEN = "YOUR_GITHUB_TOKEN_HERE" 
-USERNAME = "octocat" 
-
-url = "https://api.github.com/graphql"
-headers = {"Authorization": f"Bearer {GITHUB_TOKEN}"}
-
-
-query = """
-query($username: String!) {
-  user(login: $username) {
-    name
-    bio
-    repositories(first: 10, orderBy: {field: STARGAZERS, direction: DESC}) {
-      nodes {
-        name
-        stargazerCount
-        primaryLanguage {
-          name
-        }
-      }
-    }
-    contributionsCollection {
-      contributionCalendar {
-        totalContributions
-      }
-    }
-  }
-}
-"""
-
-variables = {"username": USERNAME}
-
-print(f"Fetching GitHub data for user: {USERNAME}...")
-
-# 3. API Request 
-try:
-    response = requests.post(url, json={'query': query, 'variables': variables}, headers=headers)
-    
-    if response.status_code == 200:
-        data = response.json()
-        print("\nGraphQL Query Success!")
-        print(json.dumps(data, indent=2))
-    elif response.status_code == 401:
-        print("\nAPI Error: Unauthorized. (Token missing ya invalid hai, which is expected right now!)")
-        print(" Schema validation checker success! Query structure is 100% correct.")
-    else:
-        print(f"\nAPI Error: Status Code {response.status_code}")
-        print(response.text)
-
-except Exception as e:
-    print(f"Connection Error: {str(e)}")
+import os
+import requests
+import json
+
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN", "")
+USERNAME = os.getenv("GITHUB_USERNAME", "octocat")
+
+url = os.getenv("GITHUB_API_URL", "https://api.github.com/graphql")
+headers = {"Accept": "application/vnd.github+json"}
+if GITHUB_TOKEN:
+    headers["Authorization"] = f"Bearer {GITHUB_TOKEN}"
+
+
+query = """
+query($username: String!) {
+  user(login: $username) {
+    name
+    bio
+    repositories(first: 10, orderBy: {field: STARGAZERS, direction: DESC}) {
+      nodes {
+        name
+        stargazerCount
+        primaryLanguage {
+          name
+        }
+      }
+    }
+    contributionsCollection {
+      contributionCalendar {
+        totalContributions
+      }
+    }
+  }
+}
+"""
+
+variables = {"username": USERNAME}
+
+print(f"Fetching GitHub data for user: {USERNAME}...")
+
+# 3. API Request
+try:
+    response = requests.post(url, json={'query': query, 'variables': variables}, headers=headers)
+
+    if response.status_code == 200:
+        data = response.json()
+        print("\nGraphQL Query Success!")
+        print(json.dumps(data, indent=2))
+    elif response.status_code == 401:
+        print("\nAPI Error: Unauthorized. (Token missing ya invalid hai, which is expected right now!)")
+        print(" Schema validation checker success! Query structure is 100% correct.")
+    else:
+        print(f"\nAPI Error: Status Code {response.status_code}")
+        print(response.text)
+
+except Exception as e:
+    print(f"Connection Error: {str(e)}")