feat: LLM-анализ — индикатор прогресса, кнопка рескана, статистика на дашборде

- Добавлен статус {"status": "analyzing"} в finding.report на время LLM-анализа
- Кнопка рескана (Retry) под LLM-отчётом в ручном режиме
- LLM-статистика на дашборде: analysed / pending
- Защита от двойного анализа через per-finding asyncio.Lock
- _llm_spinner.html — фрагмент спиннера для состояния analysing
- Удалён мёртвый код: constants, i18n, CSS, queries
- Фиксы: _env_int, индексы БД, UnicodeDecodeError, time.mktime и др.
- Шаблоны: shared includes (_status_badge, _pagination)
- AGENTS.md: workflow (lint, test, commit, rebuild)

guarddog_nexus/db/queries.py

@@ -5,16 +5,13 @@ Eliminates ~90% duplicated SQL between api/*.py and web/routes.py.
 
 import datetime
 
-from sqlalchemy import Integer, cast, func, select, text
+from sqlalchemy import func, select, text
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from guarddog_nexus.constants import (
     DASHBOARD_LATEST_FLAGGED_LIMIT,
     DASHBOARD_LATEST_SCANS_LIMIT,
-    DASHBOARD_MOST_FLAGGED_LIMIT,
-    HEATMAP_DAYS,
     JSON_PATH_RULE,
-    JSON_PATH_SEVERITY,
     PACKAGE_SORT_FIELDS,
     RECENT_FLAGGED_DAYS,
     SCAN_SORT_FIELDS,
@@ -143,15 +140,13 @@ async def get_dashboard_stats(session: AsyncSession) -> dict:
     )
     total_findings = await session.scalar(select(func.count(Finding.id)))
 
-    warnings_count = await session.scalar(
+    llm_analyzed = await session.scalar(
         select(func.count(Finding.id)).where(
-            func.json_extract(Finding.data, JSON_PATH_SEVERITY) == "WARNING"
+            func.json_extract(Finding.report, "$.verdict").isnot(None)
         )
     )
-    errors_count = await session.scalar(
-        select(func.count(Finding.id)).where(
-            func.json_extract(Finding.data, JSON_PATH_SEVERITY) == "ERROR"
-        )
+    llm_pending = await session.scalar(
+        select(func.count(Finding.id)).where(Finding.report.is_(None))
     )
 
     latest_flagged = (
@@ -191,48 +186,15 @@ async def get_dashboard_stats(session: AsyncSession) -> dict:
         )
     ).all()
 
-    most_flagged = (
-        await session.execute(
-            select(
-                Scan.package_name,
-                Scan.package_version,
-                func.sum(Scan.total_findings).label("total"),
-                func.max(Scan.started_at).label("last_scan"),
-            )
-            .where(Scan.flagged == True)
-            .group_by(Scan.package_name, Scan.package_version)
-            .order_by(func.sum(Scan.total_findings).desc())
-            .limit(DASHBOARD_MOST_FLAGGED_LIMIT)
-        )
-    ).all()
-
-    max_findings = max((r.total for r in most_flagged), default=1)
-
-    days_raw = (
-        await session.execute(
-            select(
-                func.date(Scan.started_at).label("day"),
-                func.count(Scan.id).label("cnt"),
-                func.sum(cast(Scan.flagged, Integer)).label("flagged_cnt"),
-            )
-            .where(Scan.started_at >= func.datetime("now", f"-{HEATMAP_DAYS} days"))
-            .group_by("day")
-            .order_by("day")
-        )
-    ).all()
-
     return {
         "total_scans": total_scans or 0,
         "flagged_scans": flagged_scans or 0,
         "recent_flagged": recent_flagged or 0,
         "total_findings": total_findings or 0,
-        "warnings_count": warnings_count or 0,
-        "errors_count": errors_count or 0,
+        "llm_analyzed": llm_analyzed or 0,
+        "llm_pending": llm_pending or 0,
         "latest_flagged": latest_flagged,
         "latest_scans": latest_scans,
         "top_rules": [{"rule": r.rule, "count": r.cnt} for r in top_rules],
-        "most_flagged": most_flagged,
-        "max_findings": max_findings,
-        "days": [(d.day, d.cnt, d.flagged_cnt) for d in days_raw],
         "now": datetime.datetime.now(datetime.timezone.utc),
     }