integrated release notes generation

.gitignore

@@ -173,4 +173,5 @@ cython_debug/
 # PyPI configuration file
 .pypirc
 
-observability_data/*
+observability_data/*
+storage/

app/api/server/routes.py

@@ -1,10 +1,9 @@
 from fastapi import APIRouter, HTTPException, Request, Query
 from pydantic import BaseModel
 
-from models.schemas import ChatRequest
-from services.llm_service import initialize_llm_session, set_llm, get_llm, trim_messages
+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
+from git_recap.utils import parse_entries_to_txt, parse_releases_to_txt
 from aicore.llm.config import LlmConfig
 from datetime import datetime, timezone
 from typing import Optional, List
@@ -197,6 +196,83 @@ async def get_actions(
 
     return {"actions": parse_entries_to_txt(actions)}
 
+@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.
+    Validates input, fetches releases, fetches actions since latest release, and returns compiled release notes.
+    """
+    # Validate repo_filter: must be a single repo
+    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]
+
+    # Get fetcher for session
+    try:
+        fetcher = get_fetcher(session_id)
+    except HTTPException as e:
+        raise
+
+    # Check if fetcher supports fetch_releases
+    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])
+    # Filter releases for the requested repo
+    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."
+        )
+
+    # Sort releases by published_at descending (latest first)
+    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]
+
+    # Determine the start_date for actions (latest release date)
+    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.")
+    # Accept both datetime and string
+    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.")
+
+    # Fetch actions since latest release for this repo
+    # Reuse get_actions logic, but inline to avoid async call
+    # Set fetcher filters
+    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.post("/chat")
 # async def chat(
 #     chat_request: ChatRequest

app/api/server/websockets.py

@@ -1,10 +1,10 @@
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query
+from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect
 import json
 from typing import Optional
 
-from services.llm_service import initialize_llm_session, trim_messages, run_concurrent_tasks, get_llm
+from services.prompts import 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
-import ulid
 import asyncio
 
 router = APIRouter()
@@ -14,17 +14,39 @@
 active_histories = {}
 
 TRIGGER_PROMPT = """
-Consider the following history of actionables from Git and in return me the summary with N = '{N}' bullet points:
+Consider the following history of actionables from Git and return me the summary with N = '{N}' bullet points:
 
 {ACTIONS}
 """
 
-@router.websocket("/ws/{session_id}")
+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}
+"""
+
+
+@router.websocket("/ws/{session_id}/{action_type}")
 async def websocket_endpoint(
     websocket: WebSocket, 
-    session_id: Optional[str] = None
+    session_id: Optional[str] = None,
+    action_type: str="recap"
 ):
     await websocket.accept()
+
+    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
+
+    else:
+        raise HTTPException(status_code=404)
 
     # Store the connection
     active_connections[session_id] = websocket
@@ -40,16 +62,23 @@ async def websocket_endpoint(
             N = msg_json.get("n", 5)
             assert int(N) <= 15
             assert message
-            history = [
-                TRIGGER_PROMPT.format(
-                    N=N,
-                    ACTIONS=message
-                )
-            ]
+            if action_type == "recap":
+                history = [
+                    TRIGGER_PROMPT.format(
+                        N=N,
+                        ACTIONS=message
+                    )
+                ]
+            elif action_type == "release":
+                history = [
+                    TRIGGER_RELEASE_PROMPT.format(ACTIONS=message)
+                ]
+
             response = []
             async for chunk in run_concurrent_tasks(
                 llm,
-                message=history
+                message=history,
+                system_prompt=system
             ):
                 if chunk == STREAM_END_TOKEN:
                     await websocket.send_text(json.dumps({"chunk": chunk}))

app/api/services/llm_service.py

@@ -1,7 +1,7 @@
 import json
 import os
 import uuid
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 from fastapi import HTTPException
 import asyncio
 import random
@@ -10,7 +10,6 @@
 from aicore.config import Config
 from aicore.llm import Llm
 from aicore.llm.config import LlmConfig
-from services.prompts import SELECT_QUIRKY_REMARK_SYSTEM, SYSTEM, quirky_remarks
 
 def get_random_quirky_remarks(remarks_list, n=5):
     """
@@ -113,7 +112,7 @@ def trim_messages(messages, tokenizer_fn, max_tokens: Optional[int] = None):
         messages.pop(0)  # Remove from the beginning
     return messages
 
-async def run_concurrent_tasks(llm, message):
+async def run_concurrent_tasks(llm, message, system_prompt :Union[str, List[str]]):
     """
     Run concurrent tasks for the LLM and logger.
 
@@ -124,10 +123,7 @@ async def run_concurrent_tasks(llm, message):
     Yields:
         Chunks of logs from the logger.
     """
-    QUIRKY_SYSTEM = SELECT_QUIRKY_REMARK_SYSTEM.format(
-        examples=json.dumps(get_random_quirky_remarks(quirky_remarks), indent=4)
-    )
-    asyncio.create_task(llm.acomplete(message, system_prompt=[SYSTEM, QUIRKY_SYSTEM]))
+    asyncio.create_task(llm.acomplete(message, system_prompt=system_prompt))
     asyncio.create_task(_logger.distribute())
     # Stream logger output while LLM is running.
     while True:        

app/api/services/prompts.py

@@ -110,4 +110,38 @@
     "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.
+"""

app/git-recap/package.json

@@ -1,7 +1,7 @@
 {
   "name": "git-recap",
   "homepage": "https://BrunoV21.github.io/GitRecap/",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "type": "module",
   "scripts": {
     "dev": "vite",