~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
feat(metrics): add 6 new charts to star reviews analytics dashboard (#3804)
LearningCircuite2a91106f308
diff --git a/changelog.d/3804.bugfix.md b/changelog.d/3804.bugfix.mdnew file mode 100644index 0000000000..3fea1455c2--- /dev/null+++ b/changelog.d/3804.bugfix.md@@ -0,0 +1 @@+**Star Reviews analytics now count each rating once.** The `/metrics/star-reviews` queries joined `token_usage` directly, which fans out one row per LLM call — so "Recent Ratings" showed the same research duplicated (far fewer than 20 unique entries) and the LLM/search-engine breakdown counts and averages were inflated by the number of calls per research. These queries now collapse token usage to one row per research before joining. The quality-dimensions radar no longer hides real data when only some dimensions are rated, and reports a per-dimension sample size. The rating endpoint also rejects boolean values (which previously passed the 1–5 check) and overly long feedback.diff --git a/changelog.d/3804.feature.md b/changelog.d/3804.feature.mdnew file mode 100644index 0000000000..ea2e59bc11--- /dev/null+++ b/changelog.d/3804.feature.md@@ -0,0 +1 @@+**Star Reviews dashboard gains six new charts.** The `/metrics/star-reviews` page now shows a doughnut distribution, rating-volume overlay on the trends chart, research-mode comparison, LLM satisfaction breakdown (stacked bars), quality-dimensions radar, and a recent-feedback section. Two bugs were also fixed: recent ratings displayed "Invalid Date" and showed generic fallbacks instead of actual query text and mode.diff --git a/src/local_deep_research/web/routes/metrics_routes.py b/src/local_deep_research/web/routes/metrics_routes.pyindex b65d586860..525e099823 100644--- a/src/local_deep_research/web/routes/metrics_routes.py+++ b/src/local_deep_research/web/routes/metrics_routes.py@@ -13,7 +13,6 @@ from ...database.models import (Paper,PaperAppearance,RateLimitEstimate,- Research,ResearchHistory,ResearchRating,ResearchResource,@@ -1271,8 +1270,8 @@ def api_save_research_rating(research_id):rating_value = data.get("rating")if (- not rating_value- or not isinstance(rating_value, int)+ not isinstance(rating_value, int)+ or isinstance(rating_value, bool)or rating_value < 1or rating_value > 5):@@ -1286,6 +1285,51 @@ def api_save_research_rating(research_id):400,)+ # Optional sub-dimension fields (1-5)+ sub_dimensions = {}+ for field in ("accuracy", "completeness", "relevance", "readability"):+ val = data.get(field)+ if val is not None:+ if (+ not isinstance(val, int)+ or isinstance(val, bool)+ or val < 1+ or val > 5+ ):+ return (+ jsonify(+ {+ "status": "error",+ "message": f"{field} must be an integer between 1 and 5",+ }+ ),+ 400,+ )+ sub_dimensions[field] = val++ feedback_text = data.get("feedback")+ if feedback_text is not None:+ if not isinstance(feedback_text, str):+ return (+ jsonify(+ {+ "status": "error",+ "message": "feedback must be a string",+ }+ ),+ 400,+ )+ if len(feedback_text) > 10000:+ return (+ jsonify(+ {+ "status": "error",+ "message": "feedback must be 10000 characters or fewer",+ }+ ),+ 400,+ )+with get_user_db_session(username) as session:# Check if rating already existsexisting_rating = (@@ -1298,10 +1342,17 @@ def api_save_research_rating(research_id):# Update existing ratingexisting_rating.rating = rating_valueexisting_rating.updated_at = func.now()+ for field, val in sub_dimensions.items():+ setattr(existing_rating, field, val)+ if feedback_text is not None:+ existing_rating.feedback = feedback_textelse:# Create new ratingnew_rating = ResearchRating(- research_id=research_id, rating=rating_value+ research_id=research_id,+ rating=rating_value,+ feedback=feedback_text,+ **sub_dimensions,)session.add(new_rating)@@ -1386,39 +1437,80 @@ def api_star_reviews():overall_stats = overall_stats.first()- # Ratings by LLM model (get from token_usage since Research doesn't have model field)- llm_ratings_query = session.query(- func.coalesce(TokenUsage.model_name, "Unknown").label("model"),- func.avg(ResearchRating.rating).label("avg_rating"),- func.count(ResearchRating.rating).label("rating_count"),- func.sum(case((ResearchRating.rating >= 4, 1), else_=0)).label(- "positive_ratings"- ),- ).outerjoin(- TokenUsage, ResearchRating.research_id == TokenUsage.research_id+ # Ratings by LLM model. A research has many token_usage rows (one per+ # LLM call), so joining TokenUsage directly fans out and multiplies the+ # counts/averages. Collapse to distinct (research_id, model) pairs first+ # so each rating is counted once per model it actually used.+ research_models = (+ session.query(+ TokenUsage.research_id.label("research_id"),+ TokenUsage.model_name.label("model_name"),+ )+ .distinct()+ .subquery()+ )+ model_label = func.coalesce(research_models.c.model_name, "Unknown")++ llm_ratings_query = (+ session.query(+ model_label.label("model"),+ func.avg(ResearchRating.rating).label("avg_rating"),+ func.count(ResearchRating.rating).label("rating_count"),+ func.sum(+ case((ResearchRating.rating >= 4, 1), else_=0)+ ).label("positive_ratings"),+ func.sum(+ case((ResearchRating.rating == 3, 1), else_=0)+ ).label("neutral_ratings"),+ func.sum(+ case((ResearchRating.rating <= 2, 1), else_=0)+ ).label("negative_ratings"),+ )+ .select_from(ResearchRating)+ .outerjoin(+ research_models,+ ResearchRating.research_id == research_models.c.research_id,+ ))if time_condition is not None:llm_ratings_query = llm_ratings_query.filter(time_condition)llm_ratings = (- llm_ratings_query.group_by(TokenUsage.model_name)+ llm_ratings_query.group_by(model_label).order_by(func.avg(ResearchRating.rating).desc()).all())- # Ratings by search engine (join with token_usage to get search engine info)- search_engine_ratings_query = session.query(- func.coalesce(- TokenUsage.search_engine_selected, "Unknown"- ).label("search_engine"),- func.avg(ResearchRating.rating).label("avg_rating"),- func.count(ResearchRating.rating).label("rating_count"),- func.sum(case((ResearchRating.rating >= 4, 1), else_=0)).label(- "positive_ratings"- ),- ).outerjoin(- TokenUsage, ResearchRating.research_id == TokenUsage.research_id+ # Ratings by search engine. Same one-to-many fan-out concern as the LLM+ # query — collapse to distinct (research_id, search_engine) pairs first.+ research_engines = (+ session.query(+ TokenUsage.research_id.label("research_id"),+ TokenUsage.search_engine_selected.label("search_engine"),+ )+ .distinct()+ .subquery()+ )+ engine_label = func.coalesce(+ research_engines.c.search_engine, "Unknown"+ )++ search_engine_ratings_query = (+ session.query(+ engine_label.label("search_engine"),+ func.avg(ResearchRating.rating).label("avg_rating"),+ func.count(ResearchRating.rating).label("rating_count"),+ func.sum(+ case((ResearchRating.rating >= 4, 1), else_=0)+ ).label("positive_ratings"),+ )+ .select_from(ResearchRating)+ .outerjoin(+ research_engines,+ ResearchRating.research_id+ == research_engines.c.research_id,+ ))if time_condition is not None:@@ -1427,9 +1519,7 @@ def api_star_reviews():)search_engine_ratings = (- search_engine_ratings_query.group_by(- TokenUsage.search_engine_selected- )+ search_engine_ratings_query.group_by(engine_label).having(func.count(ResearchRating.rating) > 0).order_by(func.avg(ResearchRating.rating).desc()).all()@@ -1453,21 +1543,92 @@ def api_star_reviews():.all())- # Recent ratings with research details+ # Ratings by research mode+ mode_ratings_query = session.query(+ func.coalesce(ResearchHistory.mode, "Unknown").label("mode"),+ func.avg(ResearchRating.rating).label("avg_rating"),+ func.count(ResearchRating.rating).label("rating_count"),+ func.sum(case((ResearchRating.rating >= 4, 1), else_=0)).label(+ "positive_ratings"+ ),+ ).outerjoin(+ ResearchHistory,+ ResearchRating.research_id == ResearchHistory.id,+ )++ if time_condition is not None:+ mode_ratings_query = mode_ratings_query.filter(time_condition)++ mode_ratings = (+ mode_ratings_query.group_by(ResearchHistory.mode)+ .having(func.count(ResearchRating.rating) > 0)+ .order_by(func.avg(ResearchRating.rating).desc())+ .all()+ )++ # Quality dimension averages. Each sub-dimension is independently+ # nullable, so count them separately; dimension_count reflects rows+ # with ANY dimension filled, so the radar isn't hidden when only some+ # dimensions have data.+ dimension_stats = session.query(+ func.avg(ResearchRating.accuracy).label("avg_accuracy"),+ func.avg(ResearchRating.completeness).label("avg_completeness"),+ func.avg(ResearchRating.relevance).label("avg_relevance"),+ func.avg(ResearchRating.readability).label("avg_readability"),+ func.count(ResearchRating.accuracy).label("count_accuracy"),+ func.count(ResearchRating.completeness).label(+ "count_completeness"+ ),+ func.count(ResearchRating.relevance).label("count_relevance"),+ func.count(ResearchRating.readability).label(+ "count_readability"+ ),+ func.count(+ func.coalesce(+ ResearchRating.accuracy,+ ResearchRating.completeness,+ ResearchRating.relevance,+ ResearchRating.readability,+ )+ ).label("dimension_count"),+ )++ if time_condition is not None:+ dimension_stats = dimension_stats.filter(time_condition)++ dimension_stats = dimension_stats.first()++ # Recent ratings with research details. Join a one-row-per-research+ # model subquery instead of TokenUsage directly: a research has many+ # token_usage rows, which would fan out and make limit(20) return far+ # fewer than 20 unique ratings (the same rating duplicated per row).+ recent_model_subq = (+ session.query(+ TokenUsage.research_id.label("research_id"),+ func.max(TokenUsage.model_name).label("model_name"),+ )+ .group_by(TokenUsage.research_id)+ .subquery()+ )+recent_ratings_query = (session.query(ResearchRating.rating,ResearchRating.created_at,ResearchRating.research_id,- Research.query,- Research.mode,- TokenUsage.model_name,- Research.created_at,+ ResearchHistory.query,+ ResearchHistory.mode,+ recent_model_subq.c.model_name,+ ResearchRating.feedback,+ )+ .outerjoin(+ ResearchHistory,+ ResearchRating.research_id == ResearchHistory.id,)- .outerjoin(Research, ResearchRating.research_id == Research.id).outerjoin(- TokenUsage,- ResearchRating.research_id == TokenUsage.research_id,+ recent_model_subq,+ ResearchRating.research_id+ == recent_model_subq.c.research_id,))@@ -1482,6 +1643,28 @@ def api_star_reviews():.all())+ # Recent feedback entries (non-empty feedback text)+ recent_feedback_query = session.query(+ ResearchRating.feedback,+ ResearchRating.rating,+ ResearchRating.created_at,+ ResearchRating.research_id,+ ).filter(+ ResearchRating.feedback.isnot(None),+ ResearchRating.feedback != "",+ )++ if time_condition is not None:+ recent_feedback_query = recent_feedback_query.filter(+ time_condition+ )++ recent_feedback = (+ recent_feedback_query.order_by(ResearchRating.created_at.desc())+ .limit(20)+ .all()+ )+return jsonify({"overall_stats": {@@ -1501,6 +1684,8 @@ def api_star_reviews():"avg_rating": round(rating.avg_rating or 0, 2),"rating_count": rating.rating_count or 0,"positive_ratings": rating.positive_ratings or 0,+ "neutral_ratings": rating.neutral_ratings or 0,+ "negative_ratings": rating.negative_ratings or 0,"satisfaction_rate": round((rating.positive_ratings or 0)/ max(rating.rating_count or 1, 1)@@ -1536,7 +1721,9 @@ def api_star_reviews():"recent_ratings": [{"rating": rating.rating,- "created_at": str(rating.created_at),+ "created_at": rating.created_at.isoformat()+ if rating.created_at+ else None,"research_id": rating.research_id,"query": (rating.query@@ -1551,9 +1738,62 @@ def api_star_reviews():if rating.model_nameelse "LLM Model"),+ "feedback": rating.feedback,}for rating in recent_ratings],+ "mode_ratings": [+ {+ "mode": rating.mode,+ "avg_rating": round(rating.avg_rating or 0, 2),+ "rating_count": rating.rating_count or 0,+ "satisfaction_rate": round(+ (rating.positive_ratings or 0)+ / max(rating.rating_count or 1, 1)+ * 100,+ 1,+ ),+ }+ for rating in mode_ratings+ ],+ "quality_dimensions": {+ "avg_accuracy": round(dimension_stats.avg_accuracy, 2)+ if dimension_stats.avg_accuracy is not None+ else None,+ "avg_completeness": round(+ dimension_stats.avg_completeness, 2+ )+ if dimension_stats.avg_completeness is not None+ else None,+ "avg_relevance": round(dimension_stats.avg_relevance, 2)+ if dimension_stats.avg_relevance is not None+ else None,+ "avg_readability": round(+ dimension_stats.avg_readability, 2+ )+ if dimension_stats.avg_readability is not None+ else None,+ "dimension_count": dimension_stats.dimension_count or 0,+ "dimension_counts": {+ "accuracy": dimension_stats.count_accuracy or 0,+ "completeness": dimension_stats.count_completeness+ or 0,+ "relevance": dimension_stats.count_relevance or 0,+ "readability": dimension_stats.count_readability+ or 0,+ },+ },+ "recent_feedback": [+ {+ "feedback": rating.feedback,+ "rating": rating.rating,+ "created_at": rating.created_at.isoformat()+ if rating.created_at+ else None,+ "research_id": rating.research_id,+ }+ for rating in recent_feedback+ ],})diff --git a/src/local_deep_research/web/static/css/star_reviews.css b/src/local_deep_research/web/static/css/star_reviews.cssindex 88ffb79a53..9ddfb90311 100644--- a/src/local_deep_research/web/static/css/star_reviews.css+++ b/src/local_deep_research/web/static/css/star_reviews.css@@ -1,4 +1,4 @@-/* Star Reviews Page Styles - Extracted from templates/pages/star_reviews.html */+/* Star Reviews Page Styles */.ldr-star-reviews-container {max-width: 1200px;@@ -87,6 +87,19 @@font-size: 1.2em;}+ /* Side-by-side layout: distribution bars + doughnut */+ .ldr-satisfaction-layout {+ display: grid;+ grid-template-columns: 1fr 1fr;+ gap: 1.5rem;+ align-items: center;+ }++ .ldr-distribution-doughnut {+ position: relative;+ height: 280px;+ }+.ldr-rating-distribution {margin: 1rem 0;}@@ -216,6 +229,50 @@text-decoration: underline;}+ /* Recent feedback section */+ .ldr-recent-feedback {+ max-height: 500px;+ overflow-y: auto;+ }++ .ldr-feedback-item {+ padding: 0.75rem;+ border-bottom: 1px solid var(--border-color);+ transition: background-color 0.2s ease;+ }++ .ldr-feedback-item:hover {+ background-color: var(--bg-tertiary);+ }++ .ldr-feedback-item:last-child {+ border-bottom: none;+ }++ .ldr-feedback-text {+ color: var(--text-primary);+ font-size: 0.9rem;+ margin-bottom: 0.5rem;+ line-height: 1.5;+ }++ .ldr-feedback-meta {+ font-size: 0.8125rem;+ color: var(--text-muted);+ display: flex;+ align-items: center;+ gap: 0.375rem;+ }++ /* Empty state for charts with no data */+ .ldr-empty-state {+ text-align: center;+ padding: 2.5rem 1.5rem;+ color: var(--text-muted);+ font-size: 0.9rem;+ line-height: 1.6;+ }+.ldr-info-section {margin-bottom: 2rem;}@@ -321,6 +378,10 @@grid-template-columns: repeat(2, 1fr);}+ .ldr-satisfaction-layout {+ grid-template-columns: 1fr;+ }+.ldr-info-card {flex-direction: column;text-align: center;diff --git a/src/local_deep_research/web/static/css/styles.css b/src/local_deep_research/web/static/css/styles.cssindex a3eb03ab90..7ab484e23e 100644--- a/src/local_deep_research/web/static/css/styles.css+++ b/src/local_deep_research/web/static/css/styles.css@@ -2692,6 +2692,90 @@ input[type="number"].ldr-form-control::-webkit-inner-spin-button {margin-left: 0.5rem;}+/* Detailed Rating (sub-dimensions and feedback) */+.ldr-detailed-rating-toggle {+ background: none;+ border: none;+ color: var(--accent-tertiary);+ cursor: pointer;+ font-size: 0.8rem;+ margin-left: 0.5rem;+ padding: 0;+}++.ldr-detailed-rating-toggle:hover {+ text-decoration: underline;+}++.ldr-detailed-rating {+ margin-top: 0.5rem;+ padding: 0.75rem 1rem;+ background: var(--bg-tertiary);+ border-radius: 0.5rem;+ border: 1px solid var(--border-color);+}++.ldr-dimension-row {+ display: flex;+ align-items: center;+ gap: 0.75rem;+ margin-bottom: 0.5rem;+}++.ldr-dimension-row label {+ min-width: 100px;+ font-size: 0.85rem;+ color: var(--text-secondary);+}++.ldr-dimension-slider {+ flex: 1;+ accent-color: var(--accent-primary);+ max-width: 200px;+}++.ldr-dimension-value {+ min-width: 1.5rem;+ font-weight: 600;+ color: var(--text-primary);+ font-size: 0.85rem;+}++.ldr-feedback-row {+ margin-top: 0.5rem;+}++.ldr-feedback-row label {+ display: block;+ font-size: 0.85rem;+ color: var(--text-secondary);+ margin-bottom: 0.25rem;+}++.ldr-optional {+ color: var(--text-muted);+ font-weight: normal;+ font-size: 0.8rem;+}++.ldr-feedback-textarea {+ width: 100%;+ padding: 0.5rem;+ border: 1px solid var(--border-color);+ border-radius: 0.375rem;+ background: var(--bg-secondary);+ color: var(--text-primary);+ font-size: 0.85rem;+ font-family: inherit;+ resize: vertical;+ box-sizing: border-box;+}++.ldr-feedback-textarea:focus {+ outline: none;+ border-color: var(--accent-primary);+}+/* History Page Enhancements */.ldr-news-indicator {display: inline-flex;diff --git a/src/local_deep_research/web/static/js/components/results.js b/src/local_deep_research/web/static/js/components/results.jsindex b00be551c4..fe3354d580 100644--- a/src/local_deep_research/web/static/js/components/results.js+++ b/src/local_deep_research/web/static/js/components/results.js@@ -987,6 +987,8 @@if (!starRating || !researchId) return;const stars = starRating.querySelectorAll('.ldr-star');+ const toggleBtn = document.getElementById('ldr-detailed-rating-toggle');+ const detailPanel = document.getElementById('ldr-detailed-rating');let currentRating = 0;// Load existing rating@@ -1003,6 +1005,9 @@setRating(rating);saveRating(rating);+ // Show detailed rating toggle after first star click+ if (toggleBtn) toggleBtn.style.display = 'inline';+// Visual feedback for savingstarRating.style.opacity = '0.7';setTimeout(() => {@@ -1012,15 +1017,32 @@});starRating.addEventListener('mouseleave', () => {- // Restore the permanent rating when mouse leavessetRating(currentRating);});+ // Toggle detailed rating panel+ if (toggleBtn && detailPanel) {+ toggleBtn.addEventListener('click', () => {+ const expanded = detailPanel.style.display !== 'none';+ detailPanel.style.display = expanded ? 'none' : 'block';+ toggleBtn.textContent = expanded ? 'Details ▾' : 'Details ▴';+ toggleBtn.setAttribute('aria-expanded', String(!expanded));+ });+ }++ // Update dimension value labels when sliders change. Mark a slider as+ // "touched" so we only submit dimensions the user actually set — sliders+ // default to 3, and submitting untouched ones would pollute the averages.+ document.querySelectorAll('.ldr-dimension-slider').forEach(slider => {+ slider.addEventListener('input', () => {+ slider.dataset.touched = 'true';+ slider.nextElementSibling.textContent = slider.value;+ });+ });+function highlightStars(rating) {stars.forEach((star, index) => {- // Clear all classes firststar.classList.remove('ldr-hover', 'active');- // Add hover class for previewif (index < rating) {star.classList.add('ldr-hover');}@@ -1030,9 +1052,7 @@function setRating(rating) {currentRating = rating;stars.forEach((star, index) => {- // Clear all classes firststar.classList.remove('ldr-hover', 'active');- // Set active state for permanent ratingif (index < rating) {star.classList.add('active');}@@ -1046,6 +1066,7 @@const data = await response.json();if (data.rating) {setRating(data.rating);+ if (toggleBtn) toggleBtn.style.display = 'inline';}}} catch {@@ -1055,46 +1076,46 @@async function saveRating(rating) {try {- SafeLogger.log('Attempting to save rating:', rating);-- // Get CSRF tokenconst csrfToken = window.api ? window.api.getCsrfToken() : '';- SafeLogger.log('CSRF token:', csrfToken ? 'found' : 'missing');const headers = {'Content-Type': 'application/json',};- // Add CSRF token if availableif (csrfToken) {headers['X-CSRFToken'] = csrfToken;}+ const payload = { rating };++ // Include sub-dimensions only if the panel is open AND the user+ // moved the slider (default is 3; untouched sliders are skipped so+ // they don't fabricate dimension data).+ if (detailPanel && detailPanel.style.display !== 'none') {+ document.querySelectorAll('.ldr-dimension-slider').forEach(slider => {+ if (slider.dataset.touched === 'true') {+ payload[slider.dataset.dimension] = parseInt(slider.value, 10);+ }+ });+ const feedback = document.getElementById('ldr-rating-feedback');+ if (feedback && feedback.value.trim()) {+ payload.feedback = feedback.value.trim();+ }+ }+const response = await fetch(`/metrics/api/ratings/${researchId}`, {method: 'POST',headers,- body: JSON.stringify({ rating })+ body: JSON.stringify(payload)});- SafeLogger.log('Response status:', response.status);- const responseText = await response.text();- SafeLogger.log('Response:', responseText);-if (response.ok) {SafeLogger.log('Rating saved successfully');- try {- const responseData = JSON.parse(responseText);- if (responseData.status === 'success') {- SafeLogger.log('✅ Rating confirmed saved:', responseData.rating);- }- } catch {- SafeLogger.log('✅ Rating saved (non-JSON response)');- }} else {- SafeLogger.error('❌ Failed to save rating:', response.status, responseText);+ SafeLogger.error('Failed to save rating:', response.status);}} catch (error) {- SafeLogger.error('❌ Error saving rating:', error);+ SafeLogger.error('Error saving rating:', error);}}}diff --git a/src/local_deep_research/web/templates/pages/results.html b/src/local_deep_research/web/templates/pages/results.htmlindex f9d7bba4ca..822fcff69b 100644--- a/src/local_deep_research/web/templates/pages/results.html+++ b/src/local_deep_research/web/templates/pages/results.html@@ -57,6 +57,33 @@<span class="ldr-star" data-rating="4">★</span><span class="ldr-star" data-rating="5">★</span></div>+ <button type="button" id="ldr-detailed-rating-toggle" class="ldr-detailed-rating-toggle" aria-expanded="false" style="display:none;">Details ▾</button>+ </div>+ <div id="ldr-detailed-rating" class="ldr-detailed-rating" style="display:none;">+ <div class="ldr-dimension-row">+ <label>Accuracy</label>+ <input type="range" min="1" max="5" value="3" class="ldr-dimension-slider" data-dimension="accuracy">+ <span class="ldr-dimension-value">3</span>+ </div>+ <div class="ldr-dimension-row">+ <label>Completeness</label>+ <input type="range" min="1" max="5" value="3" class="ldr-dimension-slider" data-dimension="completeness">+ <span class="ldr-dimension-value">3</span>+ </div>+ <div class="ldr-dimension-row">+ <label>Relevance</label>+ <input type="range" min="1" max="5" value="3" class="ldr-dimension-slider" data-dimension="relevance">+ <span class="ldr-dimension-value">3</span>+ </div>+ <div class="ldr-dimension-row">+ <label>Readability</label>+ <input type="range" min="1" max="5" value="3" class="ldr-dimension-slider" data-dimension="readability">+ <span class="ldr-dimension-value">3</span>+ </div>+ <div class="ldr-feedback-row">+ <label>Feedback <span class="ldr-optional">(optional)</span></label>+ <textarea id="ldr-rating-feedback" class="ldr-feedback-textarea" placeholder="What could be improved?" rows="2"></textarea>+ </div></div></div><!-- Context Overflow Warning Banner -->diff --git a/src/local_deep_research/web/templates/pages/star_reviews.html b/src/local_deep_research/web/templates/pages/star_reviews.htmlindex c327688453..f938b5f73a 100644--- a/src/local_deep_research/web/templates/pages/star_reviews.html+++ b/src/local_deep_research/web/templates/pages/star_reviews.html@@ -47,7 +47,7 @@<div id="error" class="ldr-error" style="display: none;"></div><div id="content" style="display: none;">- <!-- Overall Statistics -->+ <!-- Overall Statistics with Doughnut --><div class="ldr-metric-card"><h3>📊 Overall Satisfaction</h3><div class="ldr-overall-stats">@@ -65,47 +65,72 @@</div></div>- <div class="ldr-rating-distribution">- <h4>Rating Distribution</h4>- <div class="ldr-rating-bar">- <div class="ldr-rating-label">5 ⭐</div>- <div class="ldr-rating-progress">- <div class="ldr-rating-fill" id="rating-5" style="width: 0%;"></div>+ <div class="ldr-satisfaction-layout">+ <div class="ldr-rating-distribution">+ <h4>Rating Distribution</h4>+ <div class="ldr-rating-bar">+ <div class="ldr-rating-label">5 ⭐</div>+ <div class="ldr-rating-progress">+ <div class="ldr-rating-fill" id="rating-5" style="width: 0%;"></div>+ </div>+ <div class="ldr-rating-count" id="count-5">0</div></div>- <div class="ldr-rating-count" id="count-5">0</div>- </div>- <div class="ldr-rating-bar">- <div class="ldr-rating-label">4 ⭐</div>- <div class="ldr-rating-progress">- <div class="ldr-rating-fill" id="rating-4" style="width: 0%;"></div>+ <div class="ldr-rating-bar">+ <div class="ldr-rating-label">4 ⭐</div>+ <div class="ldr-rating-progress">+ <div class="ldr-rating-fill" id="rating-4" style="width: 0%;"></div>+ </div>+ <div class="ldr-rating-count" id="count-4">0</div></div>- <div class="ldr-rating-count" id="count-4">0</div>- </div>- <div class="ldr-rating-bar">- <div class="ldr-rating-label">3 ⭐</div>- <div class="ldr-rating-progress">- <div class="ldr-rating-fill" id="rating-3" style="width: 0%;"></div>+ <div class="ldr-rating-bar">+ <div class="ldr-rating-label">3 ⭐</div>+ <div class="ldr-rating-progress">+ <div class="ldr-rating-fill" id="rating-3" style="width: 0%;"></div>+ </div>+ <div class="ldr-rating-count" id="count-3">0</div></div>- <div class="ldr-rating-count" id="count-3">0</div>- </div>- <div class="ldr-rating-bar">- <div class="ldr-rating-label">2 ⭐</div>- <div class="ldr-rating-progress">- <div class="ldr-rating-fill" id="rating-2" style="width: 0%;"></div>+ <div class="ldr-rating-bar">+ <div class="ldr-rating-label">2 ⭐</div>+ <div class="ldr-rating-progress">+ <div class="ldr-rating-fill" id="rating-2" style="width: 0%;"></div>+ </div>+ <div class="ldr-rating-count" id="count-2">0</div></div>- <div class="ldr-rating-count" id="count-2">0</div>- </div>- <div class="ldr-rating-bar">- <div class="ldr-rating-label">1 ⭐</div>- <div class="ldr-rating-progress">- <div class="ldr-rating-fill" id="rating-1" style="width: 0%;"></div>+ <div class="ldr-rating-bar">+ <div class="ldr-rating-label">1 ⭐</div>+ <div class="ldr-rating-progress">+ <div class="ldr-rating-fill" id="rating-1" style="width: 0%;"></div>+ </div>+ <div class="ldr-rating-count" id="count-1">0</div></div>- <div class="ldr-rating-count" id="count-1">0</div>+ </div>++ <div class="ldr-distribution-doughnut">+ <canvas id="distribution-doughnut-chart"></canvas></div></div></div><div class="ldr-metrics-grid">+ <!-- Rating Trends Over Time (with volume overlay) -->+ <div class="ldr-metric-card">+ <h3>📈 Rating Trends</h3>+ <div class="ldr-chart-container">+ <canvas id="rating-trends-chart"></canvas>+ </div>+ </div>++ <!-- Research Mode Comparison -->+ <div class="ldr-metric-card">+ <h3>🔬 Research Mode Comparison</h3>+ <div class="ldr-chart-container">+ <canvas id="mode-ratings-chart"></canvas>+ </div>+ <div id="mode-empty-state" class="ldr-empty-state" style="display: none;">+ No mode data available yet.+ </div>+ </div>+<!-- LLM Model Ratings Chart --><div class="ldr-metric-card"><h3>🤖 LLM Model Performance</h3>@@ -114,6 +139,17 @@</div></div>+ <!-- LLM Satisfaction Breakdown -->+ <div class="ldr-metric-card">+ <h3>📊 LLM Rating Breakdown</h3>+ <div class="ldr-chart-container">+ <canvas id="llm-breakdown-chart"></canvas>+ </div>+ <div id="llm-breakdown-empty-state" class="ldr-empty-state" style="display: none;">+ No LLM data available yet.+ </div>+ </div>+<!-- Search Engine Ratings Chart --><div class="ldr-metric-card"><h3>🔍 Search Engine Performance</h3>@@ -122,11 +158,14 @@</div></div>- <!-- Rating Trends Over Time -->+ <!-- Quality Dimensions Radar --><div class="ldr-metric-card">- <h3>📈 Rating Trends</h3>+ <h3>🎯 Quality Dimensions</h3><div class="ldr-chart-container">- <canvas id="rating-trends-chart"></canvas>+ <canvas id="quality-radar-chart"></canvas>+ </div>+ <div id="quality-empty-state" class="ldr-empty-state" style="display: none;">+ No detailed ratings yet. Detailed ratings will appear here once you rate research on individual quality dimensions.</div></div>@@ -134,7 +173,13 @@<div class="ldr-metric-card"><h3>🕐 Recent Ratings</h3><div class="ldr-recent-ratings" id="recent-ratings">- <!-- Recent ratings will be populated here -->+ </div>+ </div>++ <!-- Recent Feedback -->+ <div class="ldr-metric-card">+ <h3>💬 Recent Feedback</h3>+ <div class="ldr-recent-feedback" id="recent-feedback"></div></div></div>@@ -178,48 +223,48 @@</div><script>-let llmChart, searchEngineChart, trendsChart;+let llmChart, searchEngineChart, trendsChart, doughnutChart, modeChart, llmBreakdownChart, qualityRadarChart;++const escapeHtml = window.escapeHtml || function(text) {+ const div = document.createElement('div');+ div.textContent = text;+ return div.innerHTML;+};-// Initialize pagedocument.addEventListener('DOMContentLoaded', function() {loadStarReviews();-- // Period selector change handlerdocument.getElementById('period-select').addEventListener('change', loadStarReviews);});async function loadStarReviews() {- console.log('Loading star reviews...');const period = document.getElementById('period-select').value;-showLoading();try {- console.log('Fetching data for period:', period);const response = await fetch(`/metrics/api/star-reviews?period=${period}`);-if (!response.ok) {throw new Error(`HTTP ${response.status}: ${response.statusText}`);}const data = await response.json();- console.log('Received data:', data);-if (data.error) {showError(data.error);return;}- console.log('Updating charts and stats...');updateOverallStats(data.overall_stats);+ updateDoughnutChart(data.overall_stats);updateLLMChart(data.llm_ratings);updateSearchEngineChart(data.search_engine_ratings);updateTrendsChart(data.rating_trends);updateRecentRatings(data.recent_ratings);- showContent();- console.log('Star reviews loaded successfully');+ if (data.mode_ratings) updateModeChart(data.mode_ratings);+ if (data.llm_ratings) updateLLMBreakdownChart(data.llm_ratings);+ if (data.quality_dimensions) updateQualityRadar(data.quality_dimensions);+ if (data.recent_feedback) updateRecentFeedback(data.recent_feedback);+ showContent();} catch (error) {console.error('Error loading star reviews:', error);showError('Failed to load star reviews data: ' + error.message);@@ -249,30 +294,267 @@ function updateOverallStats(stats) {document.getElementById('avg-rating').textContent = stats.avg_rating;document.getElementById('total-ratings').textContent = stats.total_ratings;- // Calculate satisfaction rate (4+ stars)const satisfactionRate = stats.total_ratings > 0 ?Math.round(((stats.rating_distribution['4'] + stats.rating_distribution['5']) / stats.total_ratings) * 100) : 0;document.getElementById('satisfaction-rate').textContent = satisfactionRate + '%';- // Update rating distributionconst total = stats.total_ratings || 1;for (let i = 1; i <= 5; i++) {const count = stats.rating_distribution[i.toString()] || 0;const percentage = Math.round((count / total) * 100);-document.getElementById(`rating-${i}`).style.width = percentage + '%';document.getElementById(`count-${i}`).textContent = count;}}-function updateLLMChart(llmRatings) {- const ctx = document.getElementById('llm-ratings-chart').getContext('2d');+function updateDoughnutChart(stats) {+ const ctx = document.getElementById('distribution-doughnut-chart').getContext('2d');+ if (doughnutChart) doughnutChart.destroy();- if (llmChart) {- llmChart.destroy();+ const colors = [+ 'rgba(75, 192, 192, 0.8)',+ 'rgba(54, 162, 235, 0.8)',+ 'rgba(255, 206, 86, 0.8)',+ 'rgba(255, 159, 64, 0.8)',+ 'rgba(255, 99, 132, 0.8)',+ ];++ doughnutChart = new Chart(ctx, {+ type: 'doughnut',+ data: {+ labels: ['5 Stars', '4 Stars', '3 Stars', '2 Stars', '1 Star'],+ datasets: [{+ data: [+ stats.rating_distribution['5'] || 0,+ stats.rating_distribution['4'] || 0,+ stats.rating_distribution['3'] || 0,+ stats.rating_distribution['2'] || 0,+ stats.rating_distribution['1'] || 0,+ ],+ backgroundColor: colors,+ borderWidth: 1,+ }]+ },+ options: {+ responsive: true,+ maintainAspectRatio: false,+ cutout: '60%',+ plugins: {+ legend: {+ position: 'bottom',+ labels: { padding: 12, usePointStyle: true }+ },+ tooltip: {+ callbacks: {+ label: function(context) {+ const total = context.dataset.data.reduce((a, b) => a + b, 0);+ const pct = total > 0 ? Math.round((context.parsed / total) * 100) : 0;+ return `${context.label}: ${context.parsed} (${pct}%)`;+ }+ }+ }+ }+ },+ plugins: [{+ id: 'centerText',+ afterDraw(chart) {+ const { ctx: c, width, height } = chart;+ c.save();+ c.font = 'bold 1.5rem sans-serif';+ c.fillStyle = getComputedStyle(document.documentElement).getPropertyValue('--text-primary').trim() || '#333';+ c.textAlign = 'center';+ c.textBaseline = 'middle';+ c.fillText(stats.avg_rating || '0', width / 2, height / 2 - 8);+ c.font = '0.75rem sans-serif';+ c.fillText('avg', width / 2, height / 2 + 14);+ c.restore();+ }+ }]+ });+}++function updateTrendsChart(ratingTrends) {+ const ctx = document.getElementById('rating-trends-chart').getContext('2d');+ if (trendsChart) trendsChart.destroy();++ trendsChart = new Chart(ctx, {+ type: 'bar',+ data: {+ labels: ratingTrends.map(item => new Date(item.date).toLocaleDateString()),+ datasets: [+ {+ label: 'Daily Ratings',+ data: ratingTrends.map(item => item.count),+ backgroundColor: 'rgba(200, 200, 200, 0.3)',+ borderColor: 'rgba(200, 200, 200, 0.5)',+ borderWidth: 1,+ yAxisID: 'y1',+ order: 2,+ },+ {+ label: 'Average Rating',+ type: 'line',+ data: ratingTrends.map(item => item.avg_rating),+ borderColor: 'rgba(75, 192, 192, 1)',+ backgroundColor: 'rgba(75, 192, 192, 0.2)',+ borderWidth: 2,+ fill: true,+ tension: 0.4,+ yAxisID: 'y',+ order: 1,+ }+ ]+ },+ options: {+ responsive: true,+ maintainAspectRatio: false,+ scales: {+ y: {+ beginAtZero: true,+ max: 5,+ position: 'left',+ title: { display: true, text: 'Average Rating' }+ },+ y1: {+ beginAtZero: true,+ position: 'right',+ grid: { drawOnChartArea: false },+ title: { display: true, text: 'Number of Ratings' }+ },+ x: {+ title: { display: true, text: 'Date' }+ }+ },+ plugins: {+ legend: { display: true }+ }+ }+ });+}++function updateModeChart(modeRatings) {+ const canvas = document.getElementById('mode-ratings-chart');+ const emptyState = document.getElementById('mode-empty-state');+ if (modeChart) modeChart.destroy();++ const sortedData = modeRatings.sort((a, b) => b.avg_rating - a.avg_rating).slice(0, 10);++ if (sortedData.length === 0) {+ canvas.style.display = 'none';+ emptyState.style.display = 'block';+ return;}- // Sort by rating and take top 10+ canvas.style.display = 'block';+ emptyState.style.display = 'none';++ const ctx = canvas.getContext('2d');++ modeChart = new Chart(ctx, {+ type: 'bar',+ data: {+ labels: sortedData.map(item => item.mode || 'Unknown'),+ datasets: [{+ label: 'Average Rating',+ data: sortedData.map(item => item.avg_rating),+ backgroundColor: 'rgba(153, 102, 255, 0.8)',+ borderColor: 'rgba(153, 102, 255, 1)',+ borderWidth: 1,+ }]+ },+ options: {+ responsive: true,+ maintainAspectRatio: false,+ indexAxis: 'y',+ scales: {+ x: {+ beginAtZero: true,+ max: 5,+ title: { display: true, text: 'Average Rating' }+ }+ },+ plugins: {+ legend: { display: false },+ tooltip: {+ callbacks: {+ afterLabel: function(context) {+ const item = sortedData[context.dataIndex];+ return [`Ratings: ${item.rating_count}`, `Satisfaction: ${item.satisfaction_rate}%`];+ }+ }+ }+ }+ }+ });+}++function updateLLMBreakdownChart(llmRatings) {+ const canvas = document.getElementById('llm-breakdown-chart');+ const emptyState = document.getElementById('llm-breakdown-empty-state');+ if (llmBreakdownChart) llmBreakdownChart.destroy();++ const sortedData = llmRatings.sort((a, b) => b.avg_rating - a.avg_rating).slice(0, 10);++ if (sortedData.length === 0) {+ canvas.style.display = 'none';+ emptyState.style.display = 'block';+ return;+ }++ canvas.style.display = 'block';+ emptyState.style.display = 'none';++ const ctx = canvas.getContext('2d');++ llmBreakdownChart = new Chart(ctx, {+ type: 'bar',+ data: {+ labels: sortedData.map(item => item.model || 'Unknown'),+ datasets: [+ {+ label: 'Positive (4-5)',+ data: sortedData.map(item => item.positive_ratings || 0),+ backgroundColor: 'rgba(75, 192, 192, 0.8)',+ borderWidth: 1,+ },+ {+ label: 'Neutral (3)',+ data: sortedData.map(item => item.neutral_ratings || 0),+ backgroundColor: 'rgba(255, 206, 86, 0.8)',+ borderWidth: 1,+ },+ {+ label: 'Negative (1-2)',+ data: sortedData.map(item => item.negative_ratings || 0),+ backgroundColor: 'rgba(255, 99, 132, 0.8)',+ borderWidth: 1,+ },+ ]+ },+ options: {+ responsive: true,+ maintainAspectRatio: false,+ indexAxis: 'y',+ scales: {+ x: {+ stacked: true,+ title: { display: true, text: 'Number of Ratings' }+ },+ y: {+ stacked: true,+ }+ },+ plugins: {+ legend: { position: 'bottom' }+ }+ }+ });+}++function updateLLMChart(llmRatings) {+ const ctx = document.getElementById('llm-ratings-chart').getContext('2d');+ if (llmChart) llmChart.destroy();+const sortedData = llmRatings.sort((a, b) => b.avg_rating - a.avg_rating).slice(0, 10);llmChart = new Chart(ctx, {@@ -294,31 +576,19 @@ function updateLLMChart(llmRatings) {y: {beginAtZero: true,max: 5,- title: {- display: true,- text: 'Average Rating (Stars)'- }+ title: { display: true, text: 'Average Rating (Stars)' }},x: {- title: {- display: true,- text: 'LLM Models'- }+ title: { display: true, text: 'LLM Models' }}},plugins: {- legend: {- display: false- },+ legend: { display: false },tooltip: {callbacks: {afterLabel: function(context) {- const index = context.dataIndex;- const item = sortedData[index];- return [- `Ratings: ${item.rating_count}`,- `Satisfaction: ${item.satisfaction_rate}%`- ];+ const item = sortedData[context.dataIndex];+ return [`Ratings: ${item.rating_count}`, `Satisfaction: ${item.satisfaction_rate}%`];}}}@@ -329,12 +599,8 @@ function updateLLMChart(llmRatings) {function updateSearchEngineChart(searchEngineRatings) {const ctx = document.getElementById('search-engine-ratings-chart').getContext('2d');+ if (searchEngineChart) searchEngineChart.destroy();- if (searchEngineChart) {- searchEngineChart.destroy();- }-- // Sort by rating and take top 10const sortedData = searchEngineRatings.sort((a, b) => b.avg_rating - a.avg_rating).slice(0, 10);searchEngineChart = new Chart(ctx, {@@ -356,31 +622,19 @@ function updateSearchEngineChart(searchEngineRatings) {y: {beginAtZero: true,max: 5,- title: {- display: true,- text: 'Average Rating (Stars)'- }+ title: { display: true, text: 'Average Rating (Stars)' }},x: {- title: {- display: true,- text: 'Search Engines'- }+ title: { display: true, text: 'Search Engines' }}},plugins: {- legend: {- display: false- },+ legend: { display: false },tooltip: {callbacks: {afterLabel: function(context) {- const index = context.dataIndex;- const item = sortedData[index];- return [- `Ratings: ${item.rating_count}`,- `Satisfaction: ${item.satisfaction_rate}%`- ];+ const item = sortedData[context.dataIndex];+ return [`Ratings: ${item.rating_count}`, `Satisfaction: ${item.satisfaction_rate}%`];}}}@@ -389,49 +643,67 @@ function updateSearchEngineChart(searchEngineRatings) {});}-function updateTrendsChart(ratingTrends) {- const ctx = document.getElementById('rating-trends-chart').getContext('2d');+function updateQualityRadar(dims) {+ const canvas = document.getElementById('quality-radar-chart');+ const emptyState = document.getElementById('quality-empty-state');- if (trendsChart) {- trendsChart.destroy();+ if (!dims.dimension_count || dims.dimension_count === 0) {+ canvas.style.display = 'none';+ emptyState.style.display = 'block';+ return;}- trendsChart = new Chart(ctx, {- type: 'line',+ canvas.style.display = 'block';+ emptyState.style.display = 'none';++ const ctx = canvas.getContext('2d');+ if (qualityRadarChart) qualityRadarChart.destroy();++ qualityRadarChart = new Chart(ctx, {+ type: 'radar',data: {- labels: ratingTrends.map(item => new Date(item.date).toLocaleDateString()),+ labels: ['Accuracy', 'Completeness', 'Relevance', 'Readability'],datasets: [{- label: 'Average Rating',- data: ratingTrends.map(item => item.avg_rating),- borderColor: 'rgba(75, 192, 192, 1)',- backgroundColor: 'rgba(75, 192, 192, 0.2)',+ label: 'Quality Score',+ data: [dims.avg_accuracy, dims.avg_completeness, dims.avg_relevance, dims.avg_readability],+ backgroundColor: 'rgba(153, 102, 255, 0.2)',+ borderColor: 'rgba(153, 102, 255, 1)',borderWidth: 2,- fill: true,- tension: 0.4+ pointBackgroundColor: 'rgba(153, 102, 255, 1)',+ pointRadius: 5,}]},options: {responsive: true,maintainAspectRatio: false,scales: {- y: {+ r: {beginAtZero: true,max: 5,- title: {- display: true,- text: 'Average Rating'- }- },- x: {- title: {- display: true,- text: 'Date'- }+ ticks: { stepSize: 1 },+ pointLabels: { font: { size: 12 } }}},plugins: {- legend: {- display: false+ legend: { display: false },+ tooltip: {+ callbacks: {+ label: function(context) {+ const counts = dims.dimension_counts || {};+ const perAxis = [+ counts.accuracy,+ counts.completeness,+ counts.relevance,+ counts.readability,+ ][context.dataIndex];+ const n = perAxis !== undefined ? perAxis : dims.dimension_count;+ const score = context.parsed.r;+ if (score === null || score === undefined) {+ return `${context.label}: no ratings`;+ }+ return `${context.label}: ${score.toFixed(1)}/5 (${n} ratings)`;+ }+ }}}}@@ -452,17 +724,17 @@ function updateRecentRatings(recentRatings) {item.className = 'ldr-rating-item';const stars = '⭐'.repeat(rating.rating);- const date = new Date(rating.rated_at).toLocaleDateString();+ const date = new Date(rating.created_at).toLocaleDateString();item.innerHTML = `<div class="ldr-rating-details"><div class="ldr-rating-query"><a href="/results/${encodeURIComponent(rating.research_id)}" class="ldr-rating-link">- ${window.escapeHtml(rating.query)}+ ${escapeHtml(rating.query)}</a></div><div class="ldr-rating-meta">- ${window.escapeHtml(rating.llm_model)} • ${window.escapeHtml(rating.mode)} • ${date}+ ${escapeHtml(rating.llm_model)} • ${escapeHtml(rating.mode)} • ${date}</div></div><div class="ldr-rating-score">@@ -474,5 +746,34 @@ function updateRecentRatings(recentRatings) {container.appendChild(item);});}++function updateRecentFeedback(feedbackItems) {+ const container = document.getElementById('recent-feedback');+ container.innerHTML = '';++ if (!feedbackItems || feedbackItems.length === 0) {+ container.innerHTML = '<div class="ldr-empty-state">No written feedback yet. Feedback will appear here once you add comments to your ratings.</div>';+ return;+ }++ feedbackItems.forEach(item => {+ const el = document.createElement('div');+ el.className = 'ldr-feedback-item';++ const stars = '⭐'.repeat(item.rating);+ const date = new Date(item.created_at).toLocaleDateString();++ el.innerHTML = `+ <div class="ldr-feedback-text">${escapeHtml(item.feedback)}</div>+ <div class="ldr-feedback-meta">+ <span class="ldr-star-rating">${stars}</span>+ <span>${item.rating}/5</span>+ <span>• ${date}</span>+ </div>+ `;++ container.appendChild(el);+ });+}</script>{% endblock %}diff --git a/tests/web/routes/test_metrics_routes.py b/tests/web/routes/test_metrics_routes.pyindex ccbfc6462d..8d4fe6fc3f 100644--- a/tests/web/routes/test_metrics_routes.py+++ b/tests/web/routes/test_metrics_routes.py@@ -6,6 +6,51 @@ from unittest.mock import patch, MagicMockfrom datetime import datetime, UTCimport pytest+from sqlalchemy import create_engine+from sqlalchemy.orm import sessionmaker+from sqlalchemy.pool import StaticPool++from local_deep_research.database.models import (+ Base,+ ResearchHistory,+ ResearchRating,+ TokenUsage,+)+++@contextmanager+def _seeded_metrics_db(*rows):+ """Patch ``get_user_db_session`` with a real in-memory SQLite DB seeded with+ *rows* (model instances).++ Unlike the MagicMock-based patches elsewhere in this file, this runs the+ route's actual SQL, so it can catch join-cardinality bugs (e.g. the+ TokenUsage one-to-many fan-out). A ``StaticPool`` keeps a single shared+ in-memory connection so the seed data and the route see the same DB.+ """+ engine = create_engine(+ "sqlite://",+ connect_args={"check_same_thread": False},+ poolclass=StaticPool,+ )+ Base.metadata.create_all(engine)+ Session = sessionmaker(bind=engine)++ seed_session = Session()+ seed_session.add_all(rows)+ seed_session.commit()+ seed_session.close()++ @contextmanager+ def _ctx(username, password=None):+ with Session() as session:+ yield session++ with patch(+ "local_deep_research.web.routes.metrics_routes.get_user_db_session",+ side_effect=_ctx,+ ):+ yield# Metrics routes are registered under /metrics prefix@@ -380,6 +425,242 @@ class TestStarReviewsPage:assert response.status_code == 200+class TestApiStarReviews:+ """Tests for GET /metrics/api/star-reviews endpoint."""++ def test_requires_authentication(self, client):+ """Should require authentication."""+ response = client.get(f"{METRICS_PREFIX}/api/star-reviews")+ assert response.status_code in [401, 302]++ def test_returns_star_reviews_data(self, authenticated_client):+ """Should return star reviews analytics data."""+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews"+ )+ assert response.status_code == 200, (+ f"Expected 200, got {response.status_code}: "+ f"{response.get_json() if response.status_code != 404 else response.data}"+ )+ data = response.get_json()+ assert "overall_stats" in data+ assert "llm_ratings" in data+ assert "search_engine_ratings" in data+ assert "rating_trends" in data+ assert "recent_ratings" in data+ assert "mode_ratings" in data+ assert "quality_dimensions" in data+ assert "recent_feedback" in data++ def test_overall_stats_structure(self, authenticated_client):+ """Should return properly structured overall stats."""+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews"+ )+ assert response.status_code == 200+ data = response.get_json()+ stats = data["overall_stats"]+ assert "avg_rating" in stats+ assert "total_ratings" in stats+ assert "rating_distribution" in stats+ for i in range(1, 6):+ assert str(i) in stats["rating_distribution"]++ def test_llm_ratings_include_breakdown(self, authenticated_client):+ """LLM ratings should include positive/neutral/negative counts."""+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews"+ )+ assert response.status_code == 200+ data = response.get_json()+ if data["llm_ratings"]:+ first = data["llm_ratings"][0]+ assert "positive_ratings" in first+ assert "neutral_ratings" in first+ assert "negative_ratings" in first+ assert "satisfaction_rate" in first++ def test_mode_ratings_structure(self, authenticated_client):+ """Mode ratings should be a list with correct fields."""+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews"+ )+ assert response.status_code == 200+ data = response.get_json()+ assert isinstance(data["mode_ratings"], list)+ if data["mode_ratings"]:+ first = data["mode_ratings"][0]+ assert "mode" in first+ assert "avg_rating" in first+ assert "rating_count" in first+ assert "satisfaction_rate" in first++ def test_quality_dimensions_structure(self, authenticated_client):+ """Quality dimensions should include averages and count."""+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews"+ )+ assert response.status_code == 200+ dims = response.get_json()["quality_dimensions"]+ assert "avg_accuracy" in dims+ assert "avg_completeness" in dims+ assert "avg_relevance" in dims+ assert "avg_readability" in dims+ assert "dimension_count" in dims++ def test_recent_ratings_include_feedback(self, authenticated_client):+ """Recent ratings should include feedback field."""+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews"+ )+ assert response.status_code == 200+ data = response.get_json()+ assert isinstance(data["recent_feedback"], list)++ def test_accepts_period_parameter(self, authenticated_client):+ """Should accept period query parameter."""+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews?period=7d"+ )+ assert response.status_code == 200+++class TestApiSaveResearchRatingSubDimensions:+ """Tests for sub-dimension fields in POST /metrics/api/ratings/<id>."""++ def test_saves_rating_with_sub_dimensions(self, authenticated_client):+ """Should save rating with accuracy, completeness, relevance, readability."""+ with patch(+ "local_deep_research.web.routes.metrics_routes.get_user_db_session"+ ) as mock_session_ctx:+ mock_session = MagicMock()+ mock_session_ctx.return_value.__enter__ = MagicMock(+ return_value=mock_session+ )+ mock_session_ctx.return_value.__exit__ = MagicMock(+ return_value=None+ )++ mock_query = MagicMock()+ mock_query.filter_by.return_value.first.return_value = None+ mock_session.query.return_value = mock_query++ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id",+ json={+ "rating": 4,+ "accuracy": 5,+ "completeness": 4,+ "relevance": 5,+ "readability": 3,+ "feedback": "Good results",+ },+ )++ assert response.status_code == 200+ data = response.get_json()+ assert data["status"] == "success"+ mock_session.add.assert_called_once()+ added_rating = mock_session.add.call_args[0][0]+ assert added_rating.rating == 4+ assert added_rating.accuracy == 5+ assert added_rating.completeness == 4+ assert added_rating.relevance == 5+ assert added_rating.readability == 3+ assert added_rating.feedback == "Good results"++ def test_validates_sub_dimension_range(self, authenticated_client):+ """Should reject sub-dimension values outside 1-5."""+ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id",+ json={"rating": 4, "accuracy": 0},+ )+ assert response.status_code == 400++ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id",+ json={"rating": 4, "accuracy": 6},+ )+ assert response.status_code == 400++ def test_validates_feedback_is_string(self, authenticated_client):+ """Should reject non-string feedback."""+ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id",+ json={"rating": 4, "feedback": 123},+ )+ assert response.status_code == 400++ def test_saves_rating_without_sub_dimensions(self, authenticated_client):+ """Should still save rating when no sub-dimensions provided."""+ with patch(+ "local_deep_research.web.routes.metrics_routes.get_user_db_session"+ ) as mock_session_ctx:+ mock_session = MagicMock()+ mock_session_ctx.return_value.__enter__ = MagicMock(+ return_value=mock_session+ )+ mock_session_ctx.return_value.__exit__ = MagicMock(+ return_value=None+ )++ mock_query = MagicMock()+ mock_query.filter_by.return_value.first.return_value = None+ mock_session.query.return_value = mock_query++ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id",+ json={"rating": 3},+ )++ assert response.status_code == 200+ data = response.get_json()+ assert data["status"] == "success"+ mock_session.add.assert_called_once()+ added_rating = mock_session.add.call_args[0][0]+ assert added_rating.rating == 3++ def test_updates_existing_rating_with_sub_dimensions(+ self, authenticated_client+ ):+ """Should update an existing rating via setattr when record found."""+ with patch(+ "local_deep_research.web.routes.metrics_routes.get_user_db_session"+ ) as mock_session_ctx:+ mock_session = MagicMock()+ mock_session_ctx.return_value.__enter__ = MagicMock(+ return_value=mock_session+ )+ mock_session_ctx.return_value.__exit__ = MagicMock(+ return_value=None+ )++ existing_rating = MagicMock()+ existing_rating.rating = 2+ mock_query = MagicMock()+ mock_query.filter_by.return_value.first.return_value = (+ existing_rating+ )+ mock_session.query.return_value = mock_query++ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id",+ json={+ "rating": 4,+ "accuracy": 5,+ "completeness": 3,+ },+ )++ assert response.status_code == 200+ data = response.get_json()+ assert data["status"] == "success"+ assert existing_rating.rating == 4+ assert existing_rating.accuracy == 5+ assert existing_rating.completeness == 3+ mock_session.add.assert_not_called()++class TestCostAnalyticsPage:"""Tests for /metrics/costs endpoint."""@@ -1245,3 +1526,162 @@ class TestApiJournalDataDownload:data = response.get_json()assert data["success"] is Trueassert "up to date" in data["message"].lower()+++def _token_usage(research_id, model_name="gpt-4", ts=None, search_engine=None):+ """Build a minimally-valid TokenUsage row (one per simulated LLM call)."""+ return TokenUsage(+ research_id=research_id,+ model_provider="openai",+ model_name=model_name,+ prompt_tokens=1,+ completion_tokens=1,+ total_tokens=2,+ timestamp=ts or datetime.now(UTC),+ search_engine_selected=search_engine,+ )+++class TestApiStarReviewsFanOut:+ """Regression tests for the TokenUsage one-to-many fan-out (PR #3804).++ A research session has many ``token_usage`` rows (one per LLM call). The+ star-reviews endpoint used to join TokenUsage directly, which multiplied+ rating rows: ``recent_ratings`` (limited to 20) returned the same rating+ duplicated, and the LLM/search-engine breakdown counts were inflated by the+ number of LLM calls. These tests seed one rating plus several TokenUsage+ rows and assert each rating is counted exactly once.+ """++ def test_recent_ratings_not_duplicated_by_token_usage(+ self, authenticated_client+ ):+ now = datetime.now(UTC)+ rows = [+ ResearchHistory(+ id="r1",+ query="What is X?",+ mode="standard",+ status="completed",+ created_at=now.isoformat(),+ ),+ ResearchRating(research_id="r1", rating=5, created_at=now),+ _token_usage("r1", ts=now),+ _token_usage("r1", ts=now),+ _token_usage("r1", ts=now),+ ]+ with _seeded_metrics_db(*rows):+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews?period=all"+ )+ assert response.status_code == 200, response.get_json()+ recent = response.get_json()["recent_ratings"]+ assert len(recent) == 1, (+ f"fan-out: expected 1 unique rating, got {len(recent)}"+ )+ assert recent[0]["research_id"] == "r1"+ assert recent[0]["query"] == "What is X?"+ assert recent[0]["mode"] == "standard"+ assert recent[0]["llm_model"] == "gpt-4"++ def test_llm_breakdown_counts_not_inflated_by_token_usage(+ self, authenticated_client+ ):+ now = datetime.now(UTC)+ rows = [+ ResearchRating(research_id="r1", rating=5, created_at=now),+ _token_usage("r1", ts=now),+ _token_usage("r1", ts=now),+ _token_usage("r1", ts=now),+ _token_usage("r1", ts=now),+ ]+ with _seeded_metrics_db(*rows):+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews?period=all"+ )+ assert response.status_code == 200, response.get_json()+ gpt4 = [+ r+ for r in response.get_json()["llm_ratings"]+ if r["model"] == "gpt-4"+ ]+ assert len(gpt4) == 1+ assert gpt4[0]["rating_count"] == 1, "fan-out inflated rating_count"+ assert gpt4[0]["positive_ratings"] == 1, "fan-out inflated positives"+ assert gpt4[0]["avg_rating"] == 5.0++ def test_search_engine_counts_not_inflated_by_token_usage(+ self, authenticated_client+ ):+ now = datetime.now(UTC)+ rows = [+ ResearchRating(research_id="r1", rating=4, created_at=now),+ _token_usage("r1", ts=now, search_engine="searxng"),+ _token_usage("r1", ts=now, search_engine="searxng"),+ _token_usage("r1", ts=now, search_engine="searxng"),+ ]+ with _seeded_metrics_db(*rows):+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews?period=all"+ )+ assert response.status_code == 200, response.get_json()+ searxng = [+ r+ for r in response.get_json()["search_engine_ratings"]+ if r["search_engine"] == "searxng"+ ]+ assert len(searxng) == 1+ assert searxng[0]["rating_count"] == 1, "fan-out inflated count"+ assert searxng[0]["positive_ratings"] == 1+++class TestApiStarReviewsQualityDimensions:+ """Quality radar must not be suppressed when only some dimensions are set."""++ def test_radar_not_hidden_when_only_some_dimensions_set(+ self, authenticated_client+ ):+ now = datetime.now(UTC)+ # accuracy is NULL but completeness is set: the radar previously keyed+ # its empty-state on count(accuracy) and hid real data.+ rows = [+ ResearchRating(+ research_id="r1", rating=4, completeness=4, created_at=now+ ),+ ]+ with _seeded_metrics_db(*rows):+ response = authenticated_client.get(+ f"{METRICS_PREFIX}/api/star-reviews?period=all"+ )+ assert response.status_code == 200, response.get_json()+ dims = response.get_json()["quality_dimensions"]+ assert dims["dimension_count"] == 1, "radar would be hidden"+ assert dims["avg_accuracy"] is None+ assert dims["avg_completeness"] == 4.0+ assert dims["dimension_counts"]["accuracy"] == 0+ assert dims["dimension_counts"]["completeness"] == 1+++class TestApiSaveResearchRatingValidation:+ """Validation hardening for POST /metrics/api/ratings/<id> (PR #3804)."""++ def test_rejects_boolean_rating(self, authenticated_client):+ """``True`` is an int in Python but must not pass the 1-5 check."""+ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id", json={"rating": True}+ )+ assert response.status_code == 400++ def test_rejects_boolean_sub_dimension(self, authenticated_client):+ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id",+ json={"rating": 4, "accuracy": True},+ )+ assert response.status_code == 400++ def test_rejects_overlong_feedback(self, authenticated_client):+ response = authenticated_client.post(+ f"{METRICS_PREFIX}/api/ratings/test-id",+ json={"rating": 4, "feedback": "x" * 10001},+ )+ assert response.status_code == 400diff --git a/tests/web/routes/test_metrics_routes_coverage.py b/tests/web/routes/test_metrics_routes_coverage.pyindex bfdc2f18d2..d165139a3d 100644--- a/tests/web/routes/test_metrics_routes_coverage.py+++ b/tests/web/routes/test_metrics_routes_coverage.py@@ -1202,7 +1202,7 @@ class TestApiStarReviews:mock_time_filter.return_value = Nonemock_session = MagicMock()- # overall_stats+ # overall_stats (also used as dimension_stats since query.first() is shared)overall_result = MagicMock()overall_result.avg_rating = 4.2overall_result.total_ratings = 10@@ -1211,11 +1211,24 @@ class TestApiStarReviews:overall_result.three_star = 2overall_result.two_star = 1overall_result.one_star = 0+ # quality dimension fields (returned by the same query.first() mock)+ overall_result.avg_accuracy = 4.0+ overall_result.avg_completeness = 3.8+ overall_result.avg_relevance = 4.1+ overall_result.avg_readability = 3.9+ overall_result.dimension_count = 5+ overall_result.count_accuracy = 5+ overall_result.count_completeness = 4+ overall_result.count_relevance = 4+ overall_result.count_readability = 3# Set up query chainquery = MagicMock()mock_session.query.return_value = queryquery.filter.return_value = query+ query.select_from.return_value = query+ query.distinct.return_value = query+ query.subquery.return_value = queryquery.outerjoin.return_value = queryquery.group_by.return_value = queryquery.having.return_value = query