feat: implement text-to-speech service, add API routers, and define database models

src/api/main.py

@@ -12,6 +12,7 @@ from src.api.auth_routes import router as auth_router
 from src.api.notes_routes import router as notes_router
 from src.api.recommendation_routes import router as recommendation_router
 from src.api.chat_routes import router as chat_router
+from src.api.tts_routes import router as tts_router
 from src.utils.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -41,6 +42,7 @@ app.include_router(notes_router)
 app.include_router(recommendation_router)
 app.include_router(auth_router)
 app.include_router(chat_router)
+app.include_router(tts_router)
 
 @app.get("/")
 def read_root():

src/api/notes_routes.py

@@ -305,6 +305,7 @@ async def process_video_task(
         tasks[task_id]["category"] = categories
         tasks[task_id]["keyPoints"] = key_points_list
         tasks[task_id]["videoTitle"] = resolved_video_title
+        tasks[task_id]["videoDuration"] = video_duration
         tasks[task_id]["thumbnail"] = (
             f"https://img.youtube.com/vi/{video_id}/mqdefault.jpg" if video_id else ""
         )

src/api/recommendation_routes.py

@@ -90,8 +90,12 @@ async def get_recommendations(
     logger.info(f"🎯 Getting recommendations for user: {user_id}")
 
     try:
-        # ✅ Use notesCount directly from user
-        notes_count = getattr(current_user, "notesCount", 0) or 0
+        # Get notes count from analytics collection in Firestore
+        notes_count = 0
+        if db is not None and user_id:
+            analytics_doc = db.collection("analytics").document(user_id).get()
+            if analytics_doc.exists:
+                notes_count = analytics_doc.to_dict().get("notesCount", 0) or 0
 
         is_personalized = notes_count >= MIN_INTERACTIONS_FOR_PERSONALIZATION
 

src/api/tts_routes.py

@@ -0,0 +1,113 @@
+import re
+import time
+import uuid
+from pathlib import Path
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+
+from src.auth.dependencies import get_current_user
+from src.db.models import User
+from src.speech.speech import TextToSpeechService
+from src.utils.config import settings
+from src.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+router = APIRouter(prefix="/tts", tags=["Text to Speech"])
+
+MAX_TTS_CHARS = 20000
+TTS_TTL_SECONDS = 24 * 60 * 60
+
+
+class TextToSpeechRequest(BaseModel):
+    text: str = Field(..., min_length=1)
+    title: str | None = None
+    rate: str = "-10%"
+
+
+class TextToSpeechResponse(BaseModel):
+    audioId: str
+    audioUrl: str
+
+
+def _safe_user_id(user_id: str | None) -> str:
+    value = user_id or "unknown"
+    return re.sub(r"[^A-Za-z0-9_-]", "_", value)
+
+
+def _user_tts_dir(user: User) -> Path:
+    user_dir = settings.output_dir / "tts" / _safe_user_id(user.id)
+    user_dir.mkdir(parents=True, exist_ok=True)
+    return user_dir
+
+
+def _cleanup_old_tts_files(root: Path) -> None:
+    cutoff = time.time() - TTS_TTL_SECONDS
+    if not root.exists():
+        return
+
+    for file_path in root.rglob("*.mp3"):
+        try:
+            if file_path.stat().st_mtime < cutoff:
+                file_path.unlink(missing_ok=True)
+        except OSError as exc:
+            logger.warning("Failed to clean old TTS file %s: %s", file_path, exc)
+
+
+@router.post("/generate", response_model=TextToSpeechResponse)
+async def generate_tts_audio(
+    request: TextToSpeechRequest,
+    current_user: User = Depends(get_current_user),
+):
+    text = request.text.strip()
+    if not text:
+        raise HTTPException(status_code=400, detail="Text is required.")
+
+    _cleanup_old_tts_files(settings.output_dir / "tts")
+
+    if len(text) > MAX_TTS_CHARS:
+        text = text[:MAX_TTS_CHARS]
+
+    audio_id = str(uuid.uuid4())
+    output_file = _user_tts_dir(current_user) / f"{audio_id}.mp3"
+
+    try:
+        service = TextToSpeechService()
+        await service.generate_audio(
+            text=text,
+            output_file=str(output_file),
+            rate=request.rate,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.error("TTS generation failed: %s", exc)
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to generate speech audio.",
+        ) from exc
+
+    return TextToSpeechResponse(
+        audioId=audio_id,
+        audioUrl=f"/tts/audio/{audio_id}",
+    )
+
+
+@router.get("/audio/{audio_id}")
+async def get_tts_audio(
+    audio_id: str,
+    current_user: User = Depends(get_current_user),
+):
+    if not re.fullmatch(r"[A-Fa-f0-9-]{36}", audio_id):
+        raise HTTPException(status_code=400, detail="Invalid audio id.")
+
+    audio_file = _user_tts_dir(current_user) / f"{audio_id}.mp3"
+    if not audio_file.exists():
+        raise HTTPException(status_code=404, detail="Audio file not found.")
+
+    return FileResponse(
+        path=audio_file,
+        media_type="audio/mpeg",
+        filename=f"{audio_id}.mp3",
+    )

src/db/models.py

@@ -19,7 +19,6 @@ class User(BaseModel):
     age: Optional[int] = Field(default=None)
     gender: Optional[str] = Field(default=None)
     created_at: datetime = Field(default_factory=datetime.utcnow)
-    notesCount: Optional[int] = Field(default=0)
 
     class Config:
         from_attributes = True