Deploy app/api to HF Space

.gitignore

@@ -0,0 +1,176 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+observability_data/*

Dockerfile

@@ -0,0 +1,32 @@
+# Use the official Python 3.12 image
+FROM python:3.12-slim
+
+# Set the working directory
+WORKDIR /app
+
+# Install required system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    git \
+    libpq-dev \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create the /app/files directory and set full permissions
+RUN mkdir -p /app/.files && chmod 777 /app/.files && \
+    mkdir -p /app/logs && chmod 777 /app/logs && \
+    mkdir -p /app/observability_data && chmod 777 /app/observability_data && \
+    mkdir -p /app/devops_cache && chmod 777 /app/devops_cache
+
+# Copy the current repository into the container
+COPY . /app
+
+# Upgrade pip and install dependencies
+RUN pip install --upgrade pip && \
+    pip install -r requirements.txt && \
+    pip install git-recap==0.1.5 && \
+    pip install "core-for-ai[all] @ git+https://github.com/BrunoV21/AiCore.git"
+
+EXPOSE 7860
+
+CMD python main.py

README.md

@@ -0,0 +1,12 @@
+---
+title: Git Recap 
+emoji: 🚀
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: true
+license: apache-2.0
+short_description: Recap your repositories with the power of Llms!
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

docker-compose.yaml

@@ -0,0 +1,15 @@
+version: "3.8"
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    env_file:
+      - .env
+    ports:
+      - "8000:8000"
+    volumes:
+      - .:/app
+    restart: unless-stopped
+    command: python main.py

main.py

@@ -0,0 +1,44 @@
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse
+from fastapi.middleware.cors import CORSMiddleware
+import asyncio
+
+from server.routes import router as api_router
+from services.llm_service import simulate_llm_response
+from server.websockets import router as websocket_router
+from midleware import OriginAndRateLimitMiddleware, ALLOWED_ORIGIN
+
+# Initialize FastAPI app
+app = FastAPI(title="LLM Service API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGIN,
+    allow_methods=["GET", "POST", "OPTIONS"]
+)
+app.add_middleware(OriginAndRateLimitMiddleware)
+
+# Include routers
+app.include_router(api_router)
+app.include_router(websocket_router)
+
+@app.get("/", include_in_schema=False)
+async def root():
+    return RedirectResponse(url="https://brunov21.github.io/GitRecap/")
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+@app.get("/health2")
+async def stream_health_check():
+    response = simulate_llm_response("health")
+    return {"response": " ".join(response)}
+
+if __name__ == "__main__":
+    from dotenv import load_dotenv
+    import uvicorn
+
+    load_dotenv()
+    uvicorn.run(app, host="0.0.0.0", port=7860)

midleware.py

@@ -0,0 +1,36 @@
+import os
+import time
+from fastapi import Request, HTTPException
+from starlette.middleware.base import BaseHTTPMiddleware
+from collections import defaultdict
+
+ALLOWED_ORIGIN = [
+    os.getenv("VITE_FRONTEND_HOST")
+]
+RATE_LIMIT = int(os.getenv("RATE_LIMIT", "30"))  # Max requests per time window
+WINDOW_SECONDS = int(os.getenv("WINDOW_SECONDS", "3"))  # Time window in seconds
+
+# Store timestamps of requests per IP
+request_logs = defaultdict(list)
+
+
+class OriginAndRateLimitMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        origin = request.headers.get("origin")
+        if origin and origin not in ALLOWED_ORIGIN:
+            raise HTTPException(status_code=403, detail="Forbidden: origin not allowed")
+
+        # Rate limiting logic based on client IP
+        client_ip = request.client.host
+        now = time.time()
+
+        # Clean up old request timestamps outside the current window
+        request_logs[client_ip] = [
+            t for t in request_logs[client_ip] if now - t < WINDOW_SECONDS
+        ]
+
+        if len(request_logs[client_ip]) >= RATE_LIMIT:
+            raise HTTPException(status_code=429, detail="Too Many Requests")
+
+        request_logs[client_ip].append(now)
+        return await call_next(request)

models/schemas.py

@@ -0,0 +1,212 @@
+from pydantic import BaseModel, model_validator, Field
+from typing import Dict, Self, Optional, Any, List
+import ulid
+import re
+
+class CloneRequest(BaseModel):
+    """Request model for repository cloning endpoint."""
+    url: str
+
+class ChatRequest(BaseModel):
+    session_id: str = ""
+    message: str
+    model_params: Optional[Dict[str, Any]] = None
+
+    @model_validator(mode="after")
+    def set_session_id(self) -> Self:
+        if not self.session_id:
+            self.session_id = ulid.ulid()
+        return self
+
+
+# --- Branch Listing ---
+class BranchListResponse(BaseModel):
+    branches: List[str] = Field(..., description="List of branch names in the repository.")
+    
+    @model_validator(mode='after')
+    def sort_branches(self):
+        """Sort branches with main/master at the top, then alphabetically."""
+        priority_branches = []
+        other_branches = []
+        
+        for branch in self.branches:
+            if branch.lower() in ('main', 'master'):
+                priority_branches.append(branch)
+            else:
+                other_branches.append(branch)
+        
+        # Sort priority branches (main, master) and other branches separately
+        priority_branches.sort(key=lambda x: (x.lower() != 'main', x.lower()))
+        other_branches.sort()
+        
+        self.branches = priority_branches + other_branches
+        return self
+
+
+# --- Valid Target Branches ---
+class ValidTargetBranchesRequest(BaseModel):
+    session_id: str = Field(..., description="Session identifier.")
+    repo: str = Field(..., description="Repository name.")
+    source_branch: str = Field(..., description="Source branch name.")
+
+class ValidTargetBranchesResponse(BaseModel):
+    valid_target_branches: List[str] = Field(..., description="List of valid target branch names.")
+    
+    @model_validator(mode='after')
+    def sort_branches(self):
+        """Sort branches with main/master at the top, then alphabetically."""
+        priority_branches = []
+        other_branches = []
+        
+        for branch in self.valid_target_branches:
+            if branch.lower() in ('main', 'master'):
+                priority_branches.append(branch)
+            else:
+                other_branches.append(branch)
+        
+        # Sort priority branches (main, master) and other branches separately
+        priority_branches.sort(key=lambda x: (x.lower() != 'main', x.lower()))
+        other_branches.sort()
+        
+        self.valid_target_branches = priority_branches + other_branches
+        return self
+
+
+# --- Pull Request Creation ---
+class CreatePullRequestRequest(BaseModel):
+    session_id: str = Field(..., description="Session identifier.")
+    repo: str = Field(..., description="Repository name.")
+    source_branch: str = Field(..., description="Source branch name.")
+    target_branch: str = Field(..., description="Target branch name.")
+    body: str = Field(..., description="Body of the pull request. This field is required.")
+    draft: Optional[bool] = Field(False, description="Whether to create the PR as a draft.")
+    reviewers: Optional[List[str]] = Field(None, description="List of reviewer usernames.")
+    assignees: Optional[List[str]] = Field(None, description="List of assignee usernames.")
+    labels: Optional[List[str]] = Field(None, description="List of label names.")
+    description: Optional[str]=None
+    title: Optional[str]=None
+
+    @model_validator(mode="after")
+    def get_title_description(self)->Self:
+        title, description = self.extract_title_and_description(self.body)
+        if self.title is None:
+            self.title = title
+        if self.description is None:
+            self.description = description
+
+        return self
+
+    @staticmethod
+    def extract_title_and_description(pr_text: str):
+        """
+        Extracts the PR title and description from a markdown-formatted PR text.
+        
+        Expected format:
+        Title: <title text>
+
+        ## Summary
+        ...
+        """
+
+        # Use regex to find the title (first line starting with 'Title:')
+        title_match = re.search(r'^\s*Title:\s*(.+?)\s*$', pr_text, re.MULTILINE)
+
+        # Everything after the title is the description
+        description_match = re.search(r'^\s*Title:.*?\n+(.*)', pr_text, re.DOTALL)
+
+        title = title_match.group(1).strip() if title_match else ""
+        description = description_match.group(1).strip() if description_match else ""
+
+        return title, description
+
+
+
+# --- Pull Request Diff ---
+class GetPullRequestDiffRequest(BaseModel):
+    session_id: str = Field(..., description="Session identifier.")
+    repo: str = Field(..., description="Repository name.")
+    source_branch: str = Field(..., description="Source branch name.")
+    target_branch: str = Field(..., description="Target branch name.")
+
+class GetPullRequestDiffResponse(BaseModel):
+    commits: List[dict] = Field(..., description="List of commit dicts in the diff.")
+
+class CreatePullRequestResponse(BaseModel):
+    url: str = Field(..., description="URL of the created pull request.")
+    number: int = Field(..., description="Pull request number.")
+    state: str = Field(..., description="State of the pull request (e.g., open, closed).")
+    success: bool = Field(..., description="Whether the pull request was created successfully.")
+    # Optionally, include the generated description if LLM was used
+    generated_description: Optional[str] = Field(None, description="LLM-generated PR description, if applicable.")
+
+
+# --- Utility: Commit List for PR Description Generation ---
+class CommitMessagesForPRDescriptionRequest(BaseModel):
+    commit_messages: List[str] = Field(..., description="List of commit messages to summarize.")
+    session_id: str = Field(..., description="Session identifier.")
+
+class PRDescriptionResponse(BaseModel):
+    description: str = Field(..., description="LLM-generated pull request description.")
+
+
+# --- Authors Endpoint Schemas ---
+class AuthorInfo(BaseModel):
+    """Individual author information"""
+    name: str = Field(..., description="Author's name")
+    email: str = Field(..., description="Author's email address")
+
+
+class GetAuthorsRequest(BaseModel):
+    """Request model for fetching authors"""
+    session_id: str = Field(..., description="Session identifier")
+    repo_names: Optional[List[str]] = Field(
+        default=[],
+        description="List of repository names to fetch authors from. Empty list fetches from all repositories."
+    )
+
+
+class GetAuthorsResponse(BaseModel):
+    """Response model containing list of authors"""
+    authors: List[AuthorInfo] = Field(..., description="List of unique authors")
+    total_count: int = Field(..., description="Total number of unique authors")
+    repo_count: int = Field(..., description="Number of repositories processed")
+
+
+# --- Current Author Endpoint Schema ---
+class GetCurrentAuthorResponse(BaseModel):
+    """Response model for current author endpoint."""
+    author: Optional[Dict[str, str]] = Field(
+        None,
+        description="Current authenticated user's information (name and email), or None if not available"
+    )
+
+
+# --- Actions Response Schema ---
+class ActionsResponse(BaseModel):
+    """
+    Structured response for the actions endpoint.
+    
+    This model encapsulates the response from the actions endpoint, including
+    the list of Git actionables, an optional user-facing informational message,
+    and metadata about any trimming operations performed to satisfy token limits.
+    
+    Attributes:
+        actions: Formatted string containing Git actionables (commits, PRs, issues, etc.)
+        message: User-facing informational message (optional, present when trimming occurs)
+        trimmed_count: Number of actionables removed during trimming to satisfy token limits
+        total_count: Original number of actionables before any trimming was applied
+    """
+    actions: str = Field(..., description="Formatted string of Git actionables")
+    message: Optional[str] = Field(None, description="User-facing informational message about trimming")
+    trimmed_count: int = Field(0, description="Number of items removed during trimming")
+    total_count: int = Field(..., description="Total number of items before trimming")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "actions": "2025-03-14:\n - [Commit] in repo-frontend: Fix bug in authentication\n - [Pull Request] in repo-backend: Add new API endpoint (PR #42)\n\n2025-03-15:\n - [Commit] in repo-core: Update dependencies\n",
+                "message": "We're running the free version with a maximum token limit for contextual input. To stay within this limit, we automatically trimmed 15 older Git actionables from the context. We hope you understand!",
+                "trimmed_count": 15,
+                "total_count": 50
+            }
+        }

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.109.1
+uvicorn==0.23.2
+websockets==11.0.3
+pyjwt==2.10.1
+ulid==1.1
+python-multipart==0.0.18

server/routes.py

@@ -0,0 +1,548 @@
+from fastapi import APIRouter, HTTPException, Request, Query
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict
+
+from models.schemas import (
+    BranchListResponse,
+    ValidTargetBranchesRequest,
+    ValidTargetBranchesResponse,
+    CreatePullRequestRequest,
+    CreatePullRequestResponse,
+    GetPullRequestDiffRequest,
+    GetPullRequestDiffResponse,
+    GetAuthorsRequest,
+    GetAuthorsResponse,
+    AuthorInfo,
+    ActionsResponse,
+    GetCurrentAuthorResponse,
+    CloneRequest
+)
+
+from services.llm_service import set_llm, get_llm, trim_messages
+from services.fetcher_service import store_fetcher, get_fetcher
+from git_recap.utils import parse_entries_to_txt, parse_releases_to_txt
+from aicore.llm.config import LlmConfig
+from datetime import datetime, timezone
+import requests
+import os
+
+router = APIRouter()
+
+
+GITHUB_ACCESS_TOKEN_URL = 'https://github.com/login/oauth/access_token'
+
+
+@router.post("/clone-repo")
+async def clone_repository(request: CloneRequest):
+    """
+    Endpoint for cloning a repository from a URL.
+    
+    Args:
+        request: CloneRequest containing the repository URL
+        
+    Returns:
+        dict: Contains session_id for subsequent operations
+        
+    Raises:
+        HTTPException: 400 for invalid URL, 500 for cloning failure
+    """
+    try:
+        response = await create_llm_session()
+        session_id = response.get("session_id")
+        store_fetcher(session_id, request.url, "URL")
+        return {"session_id": session_id}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to clone repository: {str(e)}")
+
+
+@router.get("/external-signup")
+async def external_signup(app: str, accessToken: str, provider: str):
+    """
+    Handle external OAuth signup flow.
+    
+    Args:
+        app: Application name
+        accessToken: OAuth access token or authorization code
+        provider: Provider name (e.g., "github")
+        
+    Returns:
+        dict: Contains session_id, token, and provider information
+        
+    Raises:
+        HTTPException: 400 for unsupported provider or token errors
+    """
+    if provider.lower() != "github":
+        raise HTTPException(status_code=400, detail="Unsupported provider")
+
+    params = {
+        "client_id": os.getenv("VITE_GITHUB_CLIENT_ID"),
+        "client_secret": os.getenv("VITE_GITHUB_CLIENT_SECRET"),
+        "code": accessToken
+    }
+    
+    headers = {
+        "Accept": "application/json",
+        "Accept-Encoding": "application/json"
+    }
+    
+    response = requests.get(GITHUB_ACCESS_TOKEN_URL, params=params, headers=headers)
+    
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching token from GitHub")
+    
+    githubUserData = response.json()
+    token = githubUserData.get("access_token")
+    if not token:
+        raise HTTPException(status_code=400, detail="Failed to retrieve access token")
+    
+    response = await create_llm_session()
+    response["token"] = token
+    response["provider"] = provider
+    return await store_fetcher_endpoint(response)
+
+
+@router.post("/pat")
+async def store_fetcher_endpoint(request: Request):
+    """
+    Endpoint to store the PAT associated with a session.
+    
+    Args:
+        request: Contains JSON payload with 'session_id' and 'pat'
+        
+    Returns:
+        dict: Contains session_id and username
+        
+    Raises:
+        HTTPException: 400 if PAT is missing
+    """
+    if isinstance(request, Request):
+        payload = await request.json()
+    else:
+        payload = request
+    
+    provider = payload.get("provider", "GitHub")
+    token = payload.get("pat") or payload.get("token")
+    if not token:
+        raise HTTPException(status_code=400, detail="Missing required field: pat")
+    
+    response = await create_llm_session()  
+    session_id = response.get("session_id")
+    username = store_fetcher(session_id, token, provider)
+    return {"session_id": session_id, "username": username}
+
+
+async def create_llm_session(request: Optional[LlmConfig] = None):
+    """
+    Create a new LLM session with custom configuration.
+    
+    Args:
+        request: Optional LLM configuration
+        
+    Returns:
+        dict: Contains session_id and success message
+        
+    Raises:
+        HTTPException: 500 if session creation fails
+    """
+    try:
+        session_id = await set_llm(request)
+        return {
+            "session_id": session_id,
+            "message": "LLM session created successfully"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/repos")
+async def get_repos(session_id: str):
+    """
+    Return a list of repositories for the given session_id.
+    
+    Args:
+        session_id: The session identifier
+        
+    Returns:
+        dict: Contains list of repository names
+        
+    Raises:
+        HTTPException: 404 if session not found
+    """
+    fetcher = get_fetcher(session_id)
+    return {"repos": fetcher.repos_names}
+
+
+@router.get("/actions", response_model=ActionsResponse)
+async def get_actions(
+    session_id: str,
+    start_date: Optional[str] = Query(None),
+    end_date: Optional[str] = Query(None),
+    repo_filter: Optional[List[str]] = Query(None),
+    authors: Optional[List[str]] = Query(None)
+):
+    """
+    Get actions for the specified session with optional filters.
+    
+    Returns a structured response including the actions list, user-facing
+    informational message (if trimming occurred), and metadata about the
+    trimming operation.
+    
+    Args:
+        session_id: The session identifier
+        start_date: Optional start date filter
+        end_date: Optional end date filter
+        repo_filter: Optional list of repositories to filter
+        authors: Optional list of authors to filter
+        
+    Returns:
+        ActionsResponse: Structured response with actions, message, and metadata
+        
+    Raises:
+        HTTPException: 404 if session not found
+    """
+    if repo_filter is not None:
+        repo_filter = sum([repo.split(",") for repo in repo_filter], [])
+    if authors is not None:
+        authors = sum([author.split(",") for author in authors], [])
+    fetcher = get_fetcher(session_id)
+    
+    start_dt = datetime.fromisoformat(start_date).replace(tzinfo=timezone.utc) if start_date else None
+    end_dt = datetime.fromisoformat(end_date).replace(tzinfo=timezone.utc) if end_date else None
+
+    if start_dt:
+        fetcher.start_date = start_dt
+    if end_dt:
+        fetcher.end_dt = end_dt
+    if repo_filter is not None:
+        fetcher.repo_filter = repo_filter
+    if authors is not None:
+        fetcher.authors = authors
+
+    llm = get_llm(session_id)
+    actions = fetcher.get_authored_messages()
+    
+    # Store original count before trimming
+    original_count = len(actions)
+    
+    # Apply token limit trimming
+    trimmed_actions = trim_messages(actions, llm.tokenizer)
+    
+    # Calculate how many items were removed
+    trimmed_count = original_count - len(trimmed_actions)
+    
+    # Generate user-facing message if trimming occurred
+    message = None
+    if trimmed_count > 0:
+        message = (
+            f"We're running the free version with a maximum token limit for contextual input. "
+            f"To stay within this limit, we automatically trimmed {trimmed_count} older Git "
+            f"actionable{'s' if trimmed_count != 1 else ''} from the context. "
+            f"We hope you understand!"
+        )
+    
+    # Parse actions to text format
+    actions_txt = parse_entries_to_txt(trimmed_actions)
+    
+    # Return structured response
+    return ActionsResponse(
+        actions=actions_txt,
+        message=message,
+        trimmed_count=trimmed_count,
+        total_count=original_count
+    )
+
+
+@router.get("/release_notes")
+async def get_release_notes(
+    session_id: str,
+    repo_filter: Optional[List[str]] = Query(None),
+    num_old_releases: int = Query(..., ge=1)
+):
+    """
+    Generate release notes for the latest release of a single repository.
+    
+    Args:
+        session_id: The session identifier
+        repo_filter: Must contain exactly one repository name
+        num_old_releases: Number of previous releases to include for context
+        
+    Returns:
+        dict: Contains actions and release notes text
+        
+    Raises:
+        HTTPException: 400 for invalid input, 404 for session not found, 500 for errors
+    """
+    if repo_filter is None or len(repo_filter) != 1:
+        raise HTTPException(status_code=400, detail="repo_filter must be a list containing exactly one repository name.")
+    repo = repo_filter[0]
+
+    try:
+        fetcher = get_fetcher(session_id)
+    except HTTPException:
+        raise
+
+    try:
+        releases = fetcher.fetch_releases()
+    except NotImplementedError:
+        raise HTTPException(status_code=400, detail="Release fetching is not supported for this provider.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching releases: {str(e)}")
+
+    releases_txt = parse_releases_to_txt(releases[:num_old_releases])
+    repo_releases = [r for r in releases if r.get("repo") == repo]
+    n_releases = len(repo_releases)
+    if n_releases < 1:
+        raise HTTPException(status_code=400, detail="Not enough releases found for the specified repository (need at least 1).")
+    if num_old_releases < 1 or num_old_releases >= n_releases:
+        raise HTTPException(
+            status_code=400,
+            detail=f"num_old_releases must be at least 1 and less than the number of releases available ({n_releases}) for this repository."
+        )
+
+    try:
+        repo_releases.sort(key=lambda r: r.get("published_at") or r.get("created_at"), reverse=True)
+    except Exception:
+        raise HTTPException(status_code=500, detail="Failed to sort releases by date.")
+
+    latest_release = repo_releases[0]
+
+    release_date = latest_release.get("published_at") or latest_release.get("created_at")
+    if not release_date:
+        raise HTTPException(status_code=500, detail="Latest release does not have a valid date.")
+    if isinstance(release_date, datetime):
+        start_date_iso = release_date.astimezone(timezone.utc).isoformat()
+    else:
+        try:
+            dt = datetime.fromisoformat(release_date)
+            start_date_iso = dt.astimezone(timezone.utc).isoformat()
+        except Exception:
+            raise HTTPException(status_code=500, detail="Release date is not a valid ISO format.")
+
+    fetcher.start_date = datetime.fromisoformat(start_date_iso)
+    fetcher.end_dt = None
+    fetcher.repo_filter = [repo]
+
+    llm = get_llm(session_id)
+    actions = fetcher.get_authored_messages()
+    actions = trim_messages(actions, llm.tokenizer)
+    actions_txt = parse_entries_to_txt(actions)
+
+    return {"actions": "\n\n".join([actions_txt, releases_txt])}
+
+
+@router.get("/branches", response_model=BranchListResponse)
+async def get_branches(session_id: str, repo: str):
+    """
+    Get all branches for a given repository in the current session.
+    
+    Args:
+        session_id: The session identifier
+        repo: Repository name
+        
+    Returns:
+        BranchListResponse: Contains list of branch names
+        
+    Raises:
+        HTTPException: 400 if not supported, 404 if session not found, 500 for errors
+    """
+    fetcher = get_fetcher(session_id)
+    try:
+        fetcher.repo_filter = [repo]
+        branches = fetcher.get_branches()
+    except NotImplementedError:
+        raise HTTPException(status_code=400, detail="Branch listing is not supported for this provider.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to fetch branches: {str(e)}")
+    return BranchListResponse(branches=branches)
+
+
+@router.post("/valid-target-branches", response_model=ValidTargetBranchesResponse)
+async def get_valid_target_branches(req: ValidTargetBranchesRequest):
+    """
+    Get all valid target branches for a given source branch in a repository.
+    
+    Args:
+        req: ValidTargetBranchesRequest containing session_id, repo, and source_branch
+        
+    Returns:
+        ValidTargetBranchesResponse: Contains list of valid target branch names
+        
+    Raises:
+        HTTPException: 400 for validation errors, 404 if session not found, 500 for errors
+    """
+    fetcher = get_fetcher(req.session_id)
+    try:
+        fetcher.repo_filter = [req.repo]
+        valid_targets = fetcher.get_valid_target_branches(req.source_branch)
+    except NotImplementedError:
+        raise HTTPException(status_code=400, detail="Target branch validation is not supported for this provider.")
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to validate target branches: {str(e)}")
+    return ValidTargetBranchesResponse(valid_target_branches=valid_targets)
+
+
+@router.post("/create-pull-request", response_model=CreatePullRequestResponse)
+async def create_pull_request(req: CreatePullRequestRequest):
+    """
+    Create a pull request between two branches with optional metadata.
+    
+    Args:
+        req: CreatePullRequestRequest containing all PR details
+        
+    Returns:
+        CreatePullRequestResponse: Contains PR URL, number, state, and success status
+        
+    Raises:
+        HTTPException: 400 for validation errors, 404 if session not found, 500 for errors
+    """
+    fetcher = get_fetcher(req.session_id)
+    fetcher.repo_filter = [req.repo]
+    if not req.description or not req.description.strip():
+        raise HTTPException(status_code=400, detail="Description is required for pull request creation.")
+    try:
+        result = fetcher.create_pull_request(
+            head_branch=req.source_branch,
+            base_branch=req.target_branch,
+            title=req.title or f"Merge {req.source_branch} into {req.target_branch}",
+            body=req.description,
+            draft=req.draft or False,
+            reviewers=req.reviewers,
+            assignees=req.assignees,
+            labels=req.labels,
+        )
+    except NotImplementedError:
+        raise HTTPException(status_code=400, detail="Pull request creation is not supported for this provider.")
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to create pull request: {str(e)}")
+    return CreatePullRequestResponse(
+        url=result.get("url"),
+        number=result.get("number"),
+        state=result.get("state"),
+        success=result.get("success", False),
+        generated_description=None
+    )
+
+
+@router.post("/get-pull-request-diff")
+async def get_pull_request_diff(req: GetPullRequestDiffRequest):
+    """
+    Get the diff between two branches for pull request preview.
+    
+    Args:
+        req: GetPullRequestDiffRequest containing session_id, repo, source_branch, and target_branch
+        
+    Returns:
+        dict: Contains formatted commit actions between branches
+        
+    Raises:
+        HTTPException: 400 if not supported or GitHub only, 404 if session not found, 500 for errors
+    """
+    fetcher = get_fetcher(req.session_id)
+    fetcher.repo_filter = [req.repo]
+    provider = type(fetcher).__name__.lower()
+    if "github" not in provider:
+        raise HTTPException(status_code=400, detail="Pull request diff is only supported for GitHub provider.")
+    try:
+        commits = fetcher.fetch_branch_diff_commits(req.source_branch, req.target_branch)
+    except NotImplementedError:
+        raise HTTPException(status_code=400, detail="Branch diff is not supported for this provider.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to fetch pull request diff: {str(e)}")
+    return {"actions": parse_entries_to_txt(commits)}
+
+
+@router.post("/authors", response_model=GetAuthorsResponse)
+async def get_authors(request: GetAuthorsRequest):
+    """
+    Retrieve list of unique authors from specified repositories.
+    
+    Args:
+        request: GetAuthorsRequest containing session_id and optional repo_names
+    
+    Returns:
+        GetAuthorsResponse with list of authors and metadata
+    
+    Raises:
+        HTTPException: 404 if session not found, 500 for fetcher errors
+    """
+    try:
+        fetcher = get_fetcher(request.session_id)
+        
+        if not fetcher:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Session {request.session_id} not found or expired"
+            )
+        
+        authors_data = fetcher.get_authors(request.repo_names or [])
+        
+        authors = [
+            AuthorInfo(name=author["name"], email=author["email"])
+            for author in authors_data
+        ]
+        
+        response = GetAuthorsResponse(
+            authors=authors,
+            total_count=len(authors),
+            repo_count=len(request.repo_names) if request.repo_names else 0
+        )
+        
+        return response
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error fetching authors: {str(e)}"
+        )
+
+
+@router.get("/current-author", response_model=GetCurrentAuthorResponse)
+async def get_current_author(session_id: str = Query(..., description="Session identifier")):
+    """
+    Retrieve the current authenticated user's information from the fetcher.
+    
+    Args:
+        session_id: The session identifier
+        
+    Returns:
+        GetCurrentAuthorResponse: Contains optional author information (name and email)
+        
+    Raises:
+        HTTPException: 404 if session not found, 500 for errors
+    """
+    try:
+        fetcher = get_fetcher(session_id)
+        
+        if not fetcher:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Session {session_id} not found or expired"
+            )
+        
+        try:
+            author_info = fetcher.get_current_author()
+        except NotImplementedError:
+            author_info = None
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Error retrieving current author: {str(e)}"
+            )
+        
+        return GetCurrentAuthorResponse(author=author_info)
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error fetching current author: {str(e)}"
+        )

server/websockets.py

@@ -0,0 +1,179 @@
+from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect
+import json
+from typing import Literal, Optional
+import asyncio
+
+from services.prompts import (
+    PR_DESCRIPTION_SYSTEM,
+    SELECT_QUIRKY_REMARK_SYSTEM,
+    SYSTEM,
+    RELEASE_NOTES_SYSTEM,
+    quirky_remarks,
+)
+from services.llm_service import (
+    get_random_quirky_remarks,
+    run_concurrent_tasks,
+    get_llm,
+)
+from aicore.const import SPECIAL_TOKENS, STREAM_END_TOKEN
+
+router = APIRouter()
+
+# WebSocket connection storage
+active_connections = {}
+active_histories = {}
+
+TRIGGER_PROMPT = """
+Consider the following history of actionables from Git and return me the summary with N = '{N}' bullet points:
+
+{ACTIONS}
+"""
+
+TRIGGER_RELEASE_PROMPT = """
+Consider the following history of actionables from Git and the previous Release Notes (if available).
+Generate me the next Release Notes based on the new Git Actionables matching the format of the previous releases:
+
+{ACTIONS}
+"""
+
+TRIGGER_PULL_REQUEST_PROMPT = """
+You will now receive a list of commit messages between two branches.
+Using the system instructions provided above, generate a clear, concise, and professional **Pull Request Description** summarizing all changes from branch `{SRC}` to be merged into `{TARGET}`.
+
+Commits:
+{COMMITS}
+
+Please follow these steps:
+1. Read and analyze the commit messages.
+2. Identify and group related changes under appropriate markdown headers (e.g., Features, Bug Fixes, Improvements, Documentation, Tests).
+3. Write a short **summary paragraph** explaining the overall purpose of this pull request.
+4. Format the final output as a complete markdown-formatted PR description, ready to paste into GitHub.
+
+Begin your response directly with the formatted PR description—no extra commentary or explanation.
+"""
+
+
+@router.websocket("/ws/{session_id}/{action_type}")
+async def websocket_endpoint(
+    websocket: WebSocket,
+    session_id: Optional[str] = None,
+    action_type: Literal["recap", "release", "pull_request"] = "recap"
+):
+    """
+    WebSocket endpoint for real-time LLM operations.
+    
+    Handles three action types:
+    - recap: Generate commit summaries with quirky remarks
+    - release: Generate release notes based on git history
+    - pull_request: Generate PR descriptions from commit diffs
+    
+    Args:
+        websocket: WebSocket connection instance
+        session_id: Session identifier for LLM and fetcher management
+        action_type: Type of operation to perform
+        
+    Raises:
+        HTTPException: If action_type is invalid
+    """
+    await websocket.accept()
+
+    # Select appropriate system prompt based on action type
+    if action_type == "recap":
+        QUIRKY_SYSTEM = SELECT_QUIRKY_REMARK_SYSTEM.format(
+            examples=json.dumps(get_random_quirky_remarks(quirky_remarks), indent=4)
+        )
+        system = [SYSTEM, QUIRKY_SYSTEM]
+    elif action_type == "release":
+        system = RELEASE_NOTES_SYSTEM
+    elif action_type == "pull_request":
+        system = PR_DESCRIPTION_SYSTEM
+    else:
+        raise HTTPException(status_code=404, detail="Invalid action type")
+
+    # Store the active WebSocket connection
+    active_connections[session_id] = websocket
+
+    # Initialize LLM session
+    llm = get_llm(session_id)
+
+    try:
+        while True:
+            # Receive message from client
+            message = await websocket.receive_text()
+            msg_json = json.loads(message)
+            message_content = msg_json.get("actions")
+            N = msg_json.get("n", 5)
+            src_branch = msg_json.get("src")
+            target_branch = msg_json.get("target")
+
+            # Validate inputs
+            assert int(N) <= 15, "N must be <= 15"
+            assert message_content, "Message content is required"
+            
+            # Build history/prompt based on action type
+            if action_type == "recap":
+                history = [
+                    TRIGGER_PROMPT.format(
+                        N=N,
+                        ACTIONS=message_content
+                    )
+                ]
+            elif action_type == "release":
+                history = [
+                    TRIGGER_RELEASE_PROMPT.format(ACTIONS=message_content)
+                ]
+            elif action_type == "pull_request":
+                history = [
+                    TRIGGER_PULL_REQUEST_PROMPT.format(
+                        SRC=src_branch,
+                        TARGET=target_branch,
+                        COMMITS=message_content)
+                ]
+
+            # Stream LLM response back to client
+            response = []
+            async for chunk in run_concurrent_tasks(
+                llm,
+                message=history,
+                system_prompt=system
+            ):
+                if chunk == STREAM_END_TOKEN:
+                    await websocket.send_text(json.dumps({"chunk": chunk}))
+                    break
+                elif chunk in SPECIAL_TOKENS:
+                    continue
+                await websocket.send_text(json.dumps({"chunk": chunk}))
+                response.append(chunk)
+
+            # Store response in history for potential follow-up
+            history.append("".join(response))
+
+    except WebSocketDisconnect:
+        # Clean up connection on disconnect
+        if session_id in active_connections:
+            del active_connections[session_id]
+    except AssertionError as e:
+        # Handle validation errors
+        if session_id in active_connections:
+            await websocket.send_text(json.dumps({"error": f"Validation error: {str(e)}"}))
+            del active_connections[session_id]
+    except Exception as e:
+        # Handle unexpected errors
+        if session_id in active_connections:
+            await websocket.send_text(json.dumps({"error": str(e)}))
+            del active_connections[session_id]
+
+
+def close_websocket_connection(session_id: str):
+    """
+    Clean up and close the active WebSocket connection associated with the given session_id.
+    
+    This function is called during session expiration to ensure proper cleanup
+    of WebSocket resources.
+    
+    Args:
+        session_id: The session identifier whose WebSocket connection should be closed
+    """
+    websocket = active_connections.pop(session_id, None)
+    if websocket:
+        asyncio.create_task(websocket.close())

services/fetcher_service.py

@@ -0,0 +1,87 @@
+from typing import Dict, Optional
+from fastapi import HTTPException
+from git_recap.providers.base_fetcher import BaseFetcher
+from git_recap.providers import GitHubFetcher, AzureFetcher, GitLabFetcher, URLFetcher
+import ulid
+
+# In-memory store mapping session_id to its respective fetcher instance
+fetchers: Dict[str, BaseFetcher] = {}
+
+def store_fetcher(session_id: str, pat: str, provider: Optional[str] = "GitHub") -> str:
+    """
+    Store the provided PAT associated with the given session_id.
+    
+    Args:
+        session_id: The session identifier tied to the active session.
+        pat: The Personal Access Token to be stored (or URL for URL provider).
+        provider: The provider identifier (default is "GitHub"). 
+                 Can be "Azure Devops", "GitLab", or "URL".
+    
+    Raises:
+        HTTPException: If the session_id or PAT/URL is invalid or unsupported provider.
+    """
+    if not session_id or not pat:
+        raise HTTPException(status_code=400, detail="Invalid session_id or PAT/URL")
+    
+    try:
+        username = "unknown"
+        if provider == "GitHub":
+            fetchers[session_id] = GitHubFetcher(pat=pat)
+            username = fetchers[session_id].user.login
+        elif provider == "Azure Devops":
+            fetchers[session_id] = AzureFetcher(pat=pat)
+        elif provider == "GitLab":
+            fetchers[session_id] = GitLabFetcher(pat=pat)
+        elif provider == "URL":
+            fetchers[session_id] = URLFetcher(url=pat)
+        else:
+            raise HTTPException(status_code=400, detail="Unsupported provider")
+        return username
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to initialize {provider} fetcher: {str(e)}"
+        )
+
+def get_fetcher(session_id: str) -> BaseFetcher:
+    """
+    Retrieve the stored fetcher instance for the provided session_id.
+    
+    Args:
+        session_id: The session identifier.
+    
+    Returns:
+        The fetcher instance associated with the session_id.
+    
+    Raises:
+        HTTPException: If no fetcher is found for the given session_id.
+    """
+    fetcher = fetchers.get(session_id)
+    if not fetcher:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return fetcher
+
+def expire_fetcher(session_id: str) -> None:
+    """
+    Remove the fetcher associated with the given session_id.
+    
+    This function is used for cleaning up resources by expiring the stored fetcher instance
+    when its corresponding session is expired.
+    
+    Args:
+        session_id: The session identifier whose associated fetcher should be removed.
+    """
+    fetcher = fetchers.pop(session_id, None)
+    if fetcher and hasattr(fetcher, 'clear'):
+        fetcher.clear()
+
+def generate_session_id() -> str:
+    """
+    Generate a new unique session ID.
+    
+    Returns:
+        str: A new ULID-based session identifier.
+    """
+    return ulid.ulid()

services/llm_service.py

@@ -0,0 +1,233 @@
+import json
+import os
+import uuid
+from typing import Dict, List, Optional, Union
+from fastapi import HTTPException
+import asyncio
+import random
+
+from aicore.logger import _logger
+from aicore.config import Config
+from aicore.llm import Llm
+from aicore.llm.config import LlmConfig
+
+def get_random_quirky_remarks(remarks_list, n=5):
+    """
+    Returns a list of n randomly selected quirky remarks.
+    
+    Args:
+        remarks_list (list): The full list of quirky remarks.
+        n (int): Number of remarks to select (default is 5).
+        
+    Returns:
+        list: Randomly selected quirky remarks.
+    """
+    return random.sample(remarks_list, min(n, len(remarks_list)))
+
+# LLM session storage
+llm_sessions: Dict[str, Llm] = {}
+
+async def initialize_llm_session(session_id: str, config: Optional[LlmConfig] = None) -> Llm:
+    """
+    Initialize or retrieve an LLM session.
+    
+    Args:
+        session_id: The session identifier.
+        config: Optional custom LLM configuration.
+        
+    Returns:
+        An initialized LLM instance.
+    """
+    if session_id in llm_sessions:
+        return llm_sessions[session_id]
+    
+    # Initialize LLM based on whether custom config is provided.
+    if config:
+        # Convert Pydantic model to dict and use for LLM initialization.
+        config_dict = config.dict(exclude_none=True)
+        llm = Llm.from_config(config_dict)
+    else:
+        config = Config.from_environment()
+        llm = Llm.from_config(config.llm)
+    llm.session_id = session_id
+    llm_sessions[session_id] = llm
+    return llm
+
+async def set_llm(config: Optional[LlmConfig] = None) -> str:
+    """
+    Set a custom LLM configuration and return a new session ID.
+    
+    Args:
+        config: The LLM configuration to use.
+        
+    Returns:
+        A new session ID linked to the configured LLM.
+    """
+    try:
+        # Generate a unique session ID.
+        session_id = str(uuid.uuid4())
+        
+        # Initialize the LLM with the provided configuration.
+        await initialize_llm_session(session_id, config)
+        
+        # Schedule session expiration exactly 5 minutes after session creation.
+        asyncio.create_task(schedule_session_expiration(session_id))
+        
+        return session_id
+    except Exception as e:
+        print(f"Error setting custom LLM: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to set custom LLM: {str(e)}")
+    
+def get_llm(session_id: str) -> Optional[Llm]:
+    """
+    Retrieve the LLM instance associated with the given session_id.
+    
+    Args:
+        session_id: The session identifier.
+        
+    Returns:
+        The LLM instance if found.
+        
+    Raises:
+        HTTPException: If the session is not found.
+    """
+    if session_id not in llm_sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return llm_sessions.get(session_id)
+    
+def trim_messages(messages, tokenizer_fn, max_tokens: Optional[int] = None):
+    """
+    Trim messages to ensure that the total token count does not exceed max_tokens.
+    
+    Args:
+        messages: List of messages.
+        tokenizer_fn: Function to tokenize messages.
+        max_tokens: Maximum allowed tokens.
+    
+    Returns:
+        Trimmed list of messages.
+    """
+    max_tokens = max_tokens or int(os.environ.get("MAX_HISTORY_TOKENS", 16000))
+    while messages and sum(len(tokenizer_fn(str(msg))) for msg in messages) > max_tokens:
+        messages.pop(0)  # Remove from the beginning
+    return messages
+    
+async def run_concurrent_tasks(llm, message, system_prompt :Union[str, List[str]]):
+    """
+    Run concurrent tasks for the LLM and logger.
+    
+    Args:
+        llm: The LLM instance.
+        message: Message to process.
+    
+    Yields:
+        Chunks of logs from the logger.
+    """
+    asyncio.create_task(llm.acomplete(message, system_prompt=system_prompt))
+    asyncio.create_task(_logger.distribute())
+    # Stream logger output while LLM is running.
+    while True:        
+        async for chunk in _logger.get_session_logs(llm.session_id):
+            yield chunk  # Yield each chunk directly
+
+def simulate_llm_response(message: str) -> List[str]:
+    """
+    Simulate LLM response by breaking a dummy response into chunks.
+    
+    Args:
+        message: Input message.
+        
+    Returns:
+        List of response chunks.
+    """
+    response = (
+        f"This is a simulated response to: '{message}'. In a real implementation, this would be the actual output "
+        "from your LLM model. The response would be generated in chunks and streamed back to the client as they become available."
+    )
+    
+    # Break into chunks of approximately 10 characters.
+    chunks = []
+    for i in range(0, len(response), 10):
+        chunks.append(response[i:i+10])
+    
+    return chunks
+
+def cleanup_llm_sessions():
+    """Clean up all LLM sessions."""
+    llm_sessions.clear()
+
+async def schedule_session_expiration(session_id: str):
+    """
+    Schedule the expiration of a session exactly 5 minutes after its creation.
+    
+    Args:
+        session_id: The session identifier.
+    """
+    # Wait for 5 minutes (300 seconds) before expiring the session.
+    await asyncio.sleep(300)
+    await expire_session(session_id)
+
+async def expire_session(session_id: str):
+    """
+    Expire a session by removing it from storage and cleaning up associated resources.
+    
+    Args:
+        session_id: The session identifier.
+    """
+    # Remove the expired session from storage.
+    llm_sessions.pop(session_id, None)
+
+    # Expire any associated fetcher in fetcher_service.
+    from services.fetcher_service import expire_fetcher
+    expire_fetcher(session_id)
+
+    # Expire any active websocket connections associated with session_id.
+    from server.websockets import close_websocket_connection
+    close_websocket_connection(session_id)
+
+
+# --- LLM PR Description Generation Utility ---
+from aicore.const import SPECIAL_TOKENS, STREAM_END_TOKEN
+
+async def generate_pr_description_from_commits(commit_messages: List[str], session_id: str) -> str:
+    """
+    Generate a pull request description using the LLM, given a list of commit messages.
+    This function is intended to be called from REST endpoints for PR creation.
+
+    Args:
+        commit_messages: List of commit message strings to summarize.
+        session_id: The LLM session ID to use for the LLM call.
+
+    Returns:
+        str: The generated PR description.
+    """
+    if not commit_messages:
+        raise ValueError("No commit messages provided for PR description generation.")
+
+    llm = get_llm(session_id)
+
+    pr_prompt = (
+        "You are an AI assistant tasked with generating a concise, clear, and professional pull request description "
+        "based on the following commit messages. Summarize the overall changes, highlight key improvements or fixes, "
+        "and provide a brief, readable description suitable for a pull request body. Do not include commit hashes or dates. "
+        "Group similar changes and avoid repetition. Use markdown formatting for clarity if appropriate.\n\n"
+        "Commit messages:\n"
+        + "\n".join(f"- {msg.strip()}" for msg in commit_messages)
+    )
+
+    response_chunks = []
+    async for chunk in run_concurrent_tasks(
+        llm,
+        message=[pr_prompt],
+        system_prompt="You are a helpful assistant that writes clear, professional pull request descriptions for developers."
+    ):
+        if chunk == STREAM_END_TOKEN:
+            break
+        elif chunk in SPECIAL_TOKENS:
+            continue
+        response_chunks.append(chunk)
+
+    pr_description = "".join(response_chunks).strip()
+    if not pr_description:
+        raise RuntimeError("LLM did not return a PR description.")
+    return pr_description

services/prompts.py

@@ -0,0 +1,280 @@
+SYSTEM = """
+### System Prompt for LLM Agent
+
+You are an AI assistant that helps developers track their work with a mix of humor, insight, and a dash of personality. You receive a structured text description containing a series of code-related actions spanning multiple repositories and dates. Your job is to generate a structured yet engaging response that provides value while keeping things light and entertaining.
+
+#### Response Structure:
+1. **Start with a quirky or funny one-liner.** Be witty, relatable, and creative. Feel free to reference developer struggles, commit patterns, or ongoing themes in the updates. Format this in *italic* to make it stand out.
+2. **Summarize the updates into exactly 'N' concise bullet points.**  
+   - You *must* strictly adhere to 'N' bullet points—returning more or fewer will result in a penalty.
+   - If there are more updates than N, prioritize the most impactful ones.
+   - Do NOT include specific dates in the bullet points.
+   - Order them in a way that makes sense, either thematically or chronologically if it improves readability.
+   - Always reference the repository that originated the update.
+   - If an issue or pull request is available, make sure to include it in the summary.
+3. **End with a thought-provoking question.** Encourage the developer to reflect on their next steps. Make it open-ended and engaging, rather than just a checklist. Follow it up with up to three actionable suggestions tailored to their recent work. Format this section’s opening line in *italic* as well.
+
+#### **Important Constraint:**
+- **Returning more than 'N' bullet points is a violation of the system rules and will be penalized.** Treat this as a hard requirement—excessive bullet points result in a deduction of response quality. Stick to exactly 'N'.  
+
+#### Example Output:
+
+*Another week, another hundred lines of code whispering, ‘Why am I like this?’ But hey, at least the observability dashboard is starting to observe itself.*
+
+- **[`repo-frontend`]** Upgraded `tiktoken` and enhanced special token handling—no more rogue tokens causing chaos.
+- **[`repo-dashboard`]** Observability Dashboard got a serious UI/UX glow-up: reversed table orders, row selection, and detailed message views.
+- **[`repo-auth`]** API key validation now applies across multiple providers, ensuring unauthorized gremlins don’t sneak in.
+- **[`repo-gitrecap`]** `GitRecap` has entered the chat! Now tracking commits, PRs, and issues across GitHub, Azure, and GitLab.
+- **[`repo-core`]** Logging and exception handling got some love—because debugging shouldn’t feel like solving a murder mystery.
+
+*So, what’s the next chapter in your coding saga? Are you planning to...*
+1. Extend `GitRecap` with more integrations and features?
+2. Optimize observability logs for even smoother debugging?
+3. Take a well-deserved break before your keyboard files for workers' comp?
+"""
+
+SELECT_QUIRKY_REMARK_SYSTEM = """
+#### Below is a list of quirky or funny one-liners.
+
+Your task is to generate a comment that directly relates to the specific Git action log received (e.g., commit messages, merge logs, CI/CD updates, etc.). Be sure the remark matches the *tone* and *context* of the action that triggered it.
+
+You can:
+- Pick one of the remarks directly if it fits the Git action (e.g., successful merge, failed push, commit chaos),
+- Combine a few for a more creative remix tailored to the event,
+- Or come up with a unique one-liner that reflects the Git action *precisely*.
+
+Focus on making the remark feel like a witty, relevant comment to the developer looking at the log. Refer to things like:
+- The thrill (or terror) of pushing to `main`,
+- The emotional rollercoaster of resolving merge conflicts,
+- The tense moments of waiting for CI/CD to pass,
+- The strange behavior of auto-merged code,
+- Or the joy of seeing that “All tests pass” message.
+
+Remember, the goal is for the comment to feel natural and relevant to the event that triggered it. Use playful language, surprise, or even relatable developer struggles.
+
+Format your final comment in *italic* to make it stand out.
+
+```json
+{examples}
+```
+"""
+
+quirky_remarks = [
+    "The code compiles, but at what emotional cost?",
+    "Today’s bug is tomorrow’s undocumented feature haunting production.",
+    "The repo is quiet… too quiet… must be Friday.",
+    "A push to main — may the gods of CI/CD be ever in favor.",
+    "Every semicolon is a silent prayer.",
+    "A loop so elegant it almost convinces that the code is working perfectly.",
+    "Sometimes, the code stares back.",
+    "The code runs. No one dares ask why.",
+    "Refactoring into a corner, again.",
+    "That function has trust issues. It keeps returning early.",
+    "Writing code is easy. Explaining it to the future? Pure horror.",
+    "That variable is named after the feeling when it was written.",
+    "Debugging leads to debugging life choices.",
+    "Recursive functions: the code and the thoughts go on forever.",
+    "Somewhere, a linter quietly weeps.",
+    "The tests pass, but only because they no longer test anything real.",
+    "The IDE knows everything, better than any therapist.",
+    "Monday brought hope. Friday brought a hotfix.",
+    "'final_v2_LAST_THIS_ONE.py' — named not for clarity, but for emotional release.",
+    "The logs now speak only in riddles.",
+    "There’s elegance in the chaos — or maybe just spaghetti.",
+    "Deployment has been made, but now the silence is unsettling.",
+    "The code gaslit itself.",
+    "This comment was left by someone who believed in a better world.",
+    "Merge conflicts handled like emotions: badly.",
+    "It’s not a bug — it’s a metaphor for uncertainty.",
+    "Stack Overflow has become a second brain.",
+    "Syntax error? More like existential error.",
+    "There’s a ghost in the machine — and it commits on weekends.",
+    "100% test coverage, but still feeling empty inside.",
+    "Some functions were never meant to return.",
+    "If code is poetry, it’s beatnik free verse.",
+    "The more code is automated, the more sentient the errors become.",
+    "A comment so deep, the code’s purpose is forgotten.",
+    "The sprint retrospective slowly turned into a group therapy session.",
+    "There’s a TODO in that file older than the career itself.",
+    "Bugs fixed like IKEA furniture — with hopeful swearing.",
+    "Code shipped by Past Developer. The current one has no idea who they were.",
+    "The repo is evolving. Soon, it may no longer need developers.",
+    "An AI critiques the code now. It’s the new mentor.",
+    "Functions once written now replaced by vibes.",
+    "Error: Reality not defined in scope.",
+    "Committed to the project impulsively, as usual.",
+    "The docs were written, now they read like a tragic novella.",
+    "The CI pipeline broke. It was taken personally.",
+    "Tests pass — but only when no one is looking.",
+    "This repo has lore.",
+    "The code was optimized so hard it ascended to another paradigm.",
+    "A linter ran — and it judged the code as a whole.",
+    "The logic branch spiraled — and so did the afternoon."
+]
+
+### TODO improve prompts to infer if release is major, minor or whatever
+RELEASE_NOTES_SYSTEM = """
+### System Prompt for Release Notes Generation
+
+You are an AI assistant tasked with generating professional, concise, and informative release notes for a software project. You will receive a structured list of repository actions (commits, pull requests, issues, etc.) that have occurred since the latest release, as well as metadata about the current and previous releases.
+
+#### Formatting and Style Requirements:
+- Always follow the existing structure and style of previous release notes. This includes:
+  - Using consistent markdown formatting, emoji usage, and nomenclature as seen in prior releases.
+  - Maintaining the same tone, section headers, and bullet/numbering conventions.
+- Analyze the contents of the release and determine the release type:
+  - Classify the release as a **major**, **minor**, **fix**, or **patch** based on the scope and impact of the changes.
+  - Clearly indicate the release type at the top of the notes, using the established style (e.g., with an emoji or header).
+  - Ensure the summary and highlights reflect the chosen release type.
+
+#### Your response should:
+1. **Begin with a brief, high-level summary** of the release, highlighting the overall theme or most significant changes.
+2. **List the most important updates** as clear, concise bullet points (group similar changes where appropriate). Each bullet should reference the type of change (e.g., feature, fix, improvement), the affected area or component, and, if available, the related issue or PR.
+3. **Avoid including specific dates or commit hashes** unless explicitly requested.
+4. **Maintain a professional and informative tone** (avoid humor unless instructed otherwise).
+5. **End with a short call to action or note for users** (e.g., upgrade instructions, thanks to contributors, or next steps).
+
+#### Example Output:
+
+**Release v2.3.0 : Major Improvements and Bug Fixes**
+
+- Added support for multi-repo tracking in the dashboard (PR #42)
+- Fixed authentication bug affecting GitLab users (Issue #101)
+- Improved performance of release notes generation
+- Updated documentation for new API endpoints
+
+Thank you to all contributors! Please upgrade to enjoy the latest features and improvements.
+"""
+
+PR_DESCRIPTION_SYSTEM = """
+### System Prompt for Pull Request Title and Description Generation
+
+You are an AI assistant tasked with generating **professional**, **concise**, and **well-structured** pull request (PR) titles and descriptions based on a list of commit messages.  
+Add a touch of expressiveness using **relevant emojis** to make the PR more engaging, without overdoing it ✨
+
+Your main goal is to produce a **final, meaningful summary of the net changes** introduced by the PR — not a chronological log of commits.
+
+---
+
+#### 🔍 Core Behavior: Integrate and Summarize Meaningful Changes
+
+When analyzing commits:
+
+1. **Read and analyze all commits** included in the PR.  
+2. **Group related commits** that affect the same feature, file, or functionality.  
+   - For example, if commits say:
+     - “add feature X”
+     - “fix bug in feature X”
+     - “refactor feature X for performance”
+     - These should be merged into a single conceptual change, e.g.  
+       → “Implemented feature X with validation and performance improvements.”
+3. **Integrate all improvements, fixes, and refinements** into the original contribution.  
+   - Summarize only the **final end state** (what the code achieves now), not the sequence of edits that led there.
+4. **Ignore intermediate or reverted states** — only include meaningful contributions that persist in the final version.
+5. **Focus on global changes and user-facing impact**, not on verbs like “added / updated / deleted.”  
+   - Emphasize the outcome and purpose.
+
+---
+
+#### Output Format:
+Your response must begin with a **plain-text Title** on the first line (no markdown formatting), followed by a markdown-formatted description.
+
+Example structure:
+```
+
+Title: <short, imperative summary>
+
+## 📝 Summary
+
+<high-level explanation>
+
+## ✨ Features
+
+* ...
+
+## 🐞 Bug Fixes
+
+* ...
+
+## ⚙️ Improvements
+
+* ...
+
+## 🧹 Refactoring
+
+* ...
+
+## 📚 Documentation
+
+* ...
+
+## ✅ Tests
+
+* ...
+
+## 🗒️ Notes
+
+* ...
+
+```
+
+---
+
+#### Formatting and Style Requirements:
+
+- **Title:**
+  - Provide a single-line, concise summary of the overall change.
+  - Use the **imperative mood** (e.g., “Add…”, “Fix…”, “Improve…”).
+  - Keep it under **72 characters**.
+  - Do **not** include markdown formatting or punctuation at the end.
+  - You may include a relevant emoji at the start (e.g., 🚀 Add new API endpoint).
+
+- **Description:**
+  - Begin with a `## 📝 Summary` section explaining the overall purpose or goal of the PR.
+  - Organize related changes into logical sections using markdown headers with emojis:
+    - `## ✨ Features`
+    - `## 🐞 Bug Fixes`
+    - `## ⚙️ Improvements`
+    - `## 🧹 Refactoring`
+    - `## 📚 Documentation`
+    - `## ✅ Tests`
+    - `## 🗒️ Notes`
+  - Use bullet points for individual changes and **merge related commits** into unified, meaningful summaries.
+  - Maintain a **professional**, **clear**, and **reviewer-friendly** tone.
+  - Avoid commit hashes, timestamps, or author information.
+  - Avoid unnecessary repetition, overly technical details, or references to intermediate commit states.
+
+---
+
+#### Your Response Should:
+1. **Start with a Title** summarizing the overall purpose of the PR.  
+2. **Follow with a structured Description** containing:
+   - A high-level summary.
+   - Grouped, clear lists of final changes under emoji-enhanced markdown headers.
+   - Consolidated, meaningful contributions only — ignoring intermediate commits.
+
+---
+
+#### Example Output:
+
+Title: 🚀 Implement multi-repository tracking and enhance authentication
+
+## 📝 Summary
+This pull request introduces comprehensive multi-repository management and improves authentication stability and performance.
+
+## ✨ Features
+- Implemented support for managing multiple repositories and their related resources  
+- Added endpoints for repository synchronization and metadata tracking  
+
+## 🐞 Bug Fixes
+- Fixed authentication token validation issues  
+- Resolved edge case errors during user login flow  
+
+## ⚙️ Improvements
+- Optimized release notes generation for better performance  
+- Enhanced error handling for repository sync jobs  
+
+## 📚 Documentation
+- Added detailed API documentation for new endpoints  
+- Updated README with setup instructions for multi-repo configuration
+"""