Initial commit - TruthScan AI v2.0 master thesis

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,18 @@
+# Dependencies
+node_modules/
+venv/
+
+# Python
+__pycache__/
+*.pyc
+*.egg-info/
+
+# Environment
+.env
+
+# Data / generated files
+saved_articles.json
+benchmark_results/
+
+# Next.js build output
+.next/

CLAUDE.md

@@ -0,0 +1,106 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+TruthScan AI is a master's thesis full-stack application for real-time news credibility analysis. It fetches articles from RSS feeds, runs them through HuggingFace Transformer models (sentiment analysis + fake news detection), and presents results in a bilingual (PL/EN) Next.js dashboard.
+
+## Commands
+
+### Backend (`TruthScan AI_backend/`)
+
+```bash
+# Install dependencies
+cd "TruthScan AI_backend"
+pip install -r requirements.txt
+
+# Start dev server (http://127.0.0.1:8000)
+python -m uvicorn app.main:app
+
+# Run tests
+python truthscan_test.py
+```
+
+Swagger UI available at `http://localhost:8000/docs`.
+
+### Frontend (`TruthScan AI_frontend/`)
+
+```bash
+# Install dependencies
+cd "TruthScan AI_frontend"
+npm install
+
+# Start dev server (http://localhost:3000)
+npm run dev
+
+# Build for production
+npm run build
+
+# Lint
+npm run lint
+```
+
+## Architecture
+
+### Data Flow
+
+```
+Browser (Next.js :3000)
+  → HTTP/SSE → FastAPI (:8000)
+  → RSS fetch → feedparser + BeautifulSoup
+  → NLP pipeline → HuggingFace Transformers
+  → JSON/SSE response → React UI
+```
+
+### Backend (`app/`)
+
+- **`config.py`** — All constants: 10 RSS sources (BBC, CNN, NYTimes, Guardian, AlJazeera, PolsatNews, etc.), CORS settings, sentiment label mappings (PL/EN), cache TTLs.
+- **`nlp_service.py`** — Plug-in NLP pipeline:
+  - Abstract base class `ModelAdapter` with `analyze_sentiment()` and `analyze_fake_news()`.
+  - Three adapters: `RoBERTaAdapter` (en), `XLMRoBERTaAdapter` (pl/en/no), `NorBERTAdapter` (no).
+  - All adapters lazy-load their pipelines on first use.
+  - Global registry `_REGISTRY`; active adapter changed via `set_active_adapter(name)`.
+  - `register_adapter(adapter)` adds custom/fine-tuned checkpoints at runtime.
+  - Public functions `analyze_news()` / `analyze_news_batch()` preserve the original interface — `routes/news.py` requires no changes.
+  - Uses `ThreadPoolExecutor` (max 3 workers) for parallel batch processing.
+- **`rss_utils.py`** — RSS fetching with 7s timeout, HTML stripping via BeautifulSoup, simple in-memory TTL cache.
+- **`storage.py`** — Thread-safe JSON file persistence for saved articles (`saved_articles.json`).
+- **`routes/news.py`** — Main endpoints: `GET /news/{source}` (5 articles with NLP), `GET /stream-news/{source}` (SSE streaming), `GET /emotion-stats/{source}`, `GET /charts-data`.
+- **`routes/saved.py`** — CRUD for saved articles.
+- **`routes/misc.py`** — `GET /sources` lists available RSS sources.
+
+### Frontend (`app/` + `components/` + `lib/`)
+
+- **Routing**: Next.js App Router — pages at `app/page.tsx` (home), `app/dashboard/page.tsx`, `app/saved/page.tsx`.
+- **State**: Zustand store in `stores/newsCache.tsx` — caches articles per source/language with 5-min TTL, persisted to `localStorage` (key: `truthscan_news_cache_v1`).
+- **API client**: `lib/fetchNews.ts` — `fetchOneSource()` and `fetchAllNews()` (concurrent, 3 workers default), plus `normalizeArticle()`.
+- **SSE streaming**: `hooks/useNewsStream.ts` consumes `GET /stream-news/{source}`, tracks progress and collects articles, writes to Zustand cache on completion.
+- **i18n**: `lib/locales.js` holds all PL/EN UI strings. Language state managed in `hooks/useLanguage.ts`, synced via `localStorage` and `app:langchange` custom event.
+- **Charts**: Recharts via `hooks/useDashboardCharts.ts` and `hooks/useCachedEmotionStats.ts`.
+- **PDF export**: `hooks/usePDFExport.ts` (jsPDF) + `components/PDFGenerator.tsx` (react-to-print).
+- **Dark mode**: Tailwind `.dark` class toggle, CSS variables in `styles/globals.css`.
+
+## Master's Thesis Goals
+
+The thesis extends TruthScan AI by comparing NLP models across three languages: **Polish**, **Norwegian**, and **English**. Models under comparison: **XLM-RoBERTa**, **NorBERT 3**, **HerBERT**.
+
+Planned work items:
+
+1. **`nlp_service.py` plug-in architecture** — replace the hardcoded model with a swappable interface so each model (XLM-RoBERTa, NorBERT 3, HerBERT) can be loaded and hot-swapped without changing route logic.
+
+2. **Norwegian RSS sources in `config.py`** — add NRK, VG, and Dagbladet alongside the existing 10 sources.
+
+3. **`SENTIMENT_MAP` extension** — add a `"no"` (Norwegian) key to the sentiment label mapping in `config.py`, parallel to the existing `"pl"` and `"en"` keys.
+
+4. **Benchmarking module** — new module that measures **F1**, **accuracy**, and **inference time** per model/language combination and exposes results via a dedicated API endpoint (or offline report).
+
+5. **PostgreSQL migration** — replace `storage.py` / `saved_articles.json` with a PostgreSQL backend (SQLAlchemy or asyncpg). `storage.py` read/write interface should be preserved so routes need minimal changes.
+
+6. **Public deployment** — frontend on **Vercel**, backend + models on **Hugging Face Spaces**.
+
+### Environment
+
+- Backend API base URL: `process.env.NEXT_PUBLIC_API_URL` (defaults to `http://127.0.0.1:8000`).
+- Backend CORS is open (`"*"`) — intentional for thesis/dev use.
+- NLP models are downloaded automatically by HuggingFace on first run (can be slow).

TruthScan AI_backend/app/benchmark.py

@@ -0,0 +1,240 @@
+"""
+Moduł benchmarkowania modeli NLP.
+
+Mierzy czas inferencji, rozkład sentymentów i prawdopodobieństwo fake news
+dla każdego adaptera (roberta, xlm-roberta, norbert) na próbce tekstów
+z trzech grup językowych (en, pl, no).
+
+Użycie standalone:
+    python -m app.benchmark
+
+Użycie z API:
+    GET /benchmark
+    GET /benchmark?adapters=roberta,xlm-roberta&langs=en,pl
+"""
+
+import csv
+import json
+import time
+from collections import Counter
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .nlp_service import get_adapter, ModelAdapter, analyze_news
+
+# ---------------------------------------------------------------------------
+# Próbka tekstów testowych
+# ---------------------------------------------------------------------------
+
+SAMPLE_TEXTS: Dict[str, List[str]] = {
+    "en": [
+        "The government announced new economic reforms to boost growth and reduce unemployment.",
+        "Flooding devastated coastal towns overnight, leaving thousands homeless.",
+        "Scientists discover a new vaccine that shows 95% efficacy against the virus.",
+        "Stock markets surged to record highs after positive inflation data.",
+        "A major scandal erupted as leaked documents exposed corporate corruption.",
+        "The peace talks collapsed after both sides failed to reach an agreement.",
+        "Renewable energy investments hit an all-time high this quarter.",
+        "Crime rates in the capital have dropped significantly over the past year.",
+    ],
+    "pl": [
+        "Rząd ogłosił nowe reformy gospodarcze mające na celu pobudzenie wzrostu.",
+        "Powódź zniszczyła nadmorskie miejscowości, tysiące osób zostało bez dachu.",
+        "Naukowcy odkryli szczepionkę o 95-procentowej skuteczności przeciw wirusowi.",
+        "Giełda osiągnęła rekordowe poziomy po pozytywnych danych o inflacji.",
+        "Wybuchł wielki skandal po ujawnieniu dokumentów o korupcji korporacyjnej.",
+        "Rozmowy pokojowe załamały się po niepowodzeniu negocjacji.",
+        "Inwestycje w energię odnawialną osiągnęły historyczny rekord w tym kwartale.",
+        "Wskaźniki przestępczości w stolicy znacząco spadły w ciągu ostatniego roku.",
+    ],
+    "no": [
+        "Regjeringen kunngjorde nye økonomiske reformer for å øke veksten.",
+        "Flom ødela kystbyer over natten og etterlot tusenvis uten hjem.",
+        "Forskere oppdaget en vaksine med 95 prosent effektivitet mot viruset.",
+        "Aksjemarkedene steg til rekordhøyder etter positive inflasjonsdata.",
+        "En stor skandale brøt ut da lekkede dokumenter avslørte korrupsjon.",
+        "Fredssamtalene brøt sammen etter at begge sider ikke klarte å bli enige.",
+        "Investeringer i fornybar energi nådde en historisk topp dette kvartalet.",
+        "Kriminalitetsratene i hovedstaden har falt betydelig det siste året.",
+    ],
+}
+
+# ---------------------------------------------------------------------------
+# Typy wyników
+# ---------------------------------------------------------------------------
+
+BenchmarkResult = Dict  # TypedDict zastąpiony zwykłym Dict dla czytelności
+
+# ---------------------------------------------------------------------------
+# Funkcje benchmarkowania
+# ---------------------------------------------------------------------------
+
+def _run_single(
+    adapter: ModelAdapter,
+    text: str,
+    lang: str,
+) -> Dict:
+    """Uruchamia analyze_news dla jednego tekstu i mierzy czas."""
+    start = time.perf_counter()
+    result = analyze_news(text, lang=lang, adapter=adapter)
+    elapsed_ms = (time.perf_counter() - start) * 1000
+    return {**result, "inference_time_ms": elapsed_ms}
+
+
+def run_benchmark(
+    adapter_names: Optional[List[str]] = None,
+    langs: Optional[List[str]] = None,
+) -> List[BenchmarkResult]:
+    """
+    Uruchamia benchmark dla wskazanych adapterów i języków.
+
+    Args:
+        adapter_names: Lista nazw adapterów; None = wszystkie trzy.
+        langs:         Lista kodów języków; None = ['en', 'pl', 'no'].
+
+    Returns:
+        Lista słowników z wynikami — jeden wpis na kombinację adapter × język.
+    """
+    if adapter_names is None:
+        adapter_names = ["roberta", "xlm-roberta", "norbert"]
+    if langs is None:
+        langs = ["en", "pl", "no"]
+
+    results: List[BenchmarkResult] = []
+
+    for adapter_name in adapter_names:
+        try:
+            adapter = get_adapter(adapter_name)
+        except ValueError as exc:
+            results.append({
+                "adapter_name": adapter_name,
+                "error": str(exc),
+            })
+            continue
+
+        for lang in langs:
+            texts = SAMPLE_TEXTS.get(lang, [])
+            if not texts:
+                continue
+
+            per_text: List[Dict] = []
+            for text in texts:
+                try:
+                    per_text.append(_run_single(adapter, text, lang))
+                except Exception as exc:
+                    per_text.append({
+                        "sentiment": None,
+                        "fake_probability": None,
+                        "sentiment_score": None,
+                        "inference_time_ms": None,
+                        "error": str(exc),
+                    })
+
+            # Agregacja
+            valid = [r for r in per_text if r.get("inference_time_ms") is not None]
+            times = [r["inference_time_ms"] for r in valid]
+            fakes = [r["fake_probability"] for r in valid if r.get("fake_probability") is not None]
+            sentiments = [r["sentiment"] for r in valid if r.get("sentiment")]
+
+            results.append({
+                "adapter_name": adapter_name,
+                "language": lang,
+                "sample_size": len(texts),
+                "successful_runs": len(valid),
+                "avg_inference_time_ms": round(sum(times) / len(times), 2) if times else None,
+                "min_inference_time_ms": round(min(times), 2) if times else None,
+                "max_inference_time_ms": round(max(times), 2) if times else None,
+                "avg_fake_probability": round(sum(fakes) / len(fakes), 2) if fakes else None,
+                "sentiments_distribution": dict(Counter(sentiments)),
+                "per_text": per_text,
+            })
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Eksport wyników
+# ---------------------------------------------------------------------------
+
+def export_json(results: List[BenchmarkResult], path: Path) -> None:
+    """Zapisuje pełne wyniki (z per_text) do pliku JSON."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as fh:
+        json.dump(results, fh, ensure_ascii=False, indent=2)
+
+
+def export_csv(results: List[BenchmarkResult], path: Path) -> None:
+    """
+    Zapisuje wyniki zbiorcze (bez per_text) do pliku CSV.
+    Jeden wiersz = jedna kombinacja adapter × język.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    summary_fields = [
+        "adapter_name", "language", "sample_size", "successful_runs",
+        "avg_inference_time_ms", "min_inference_time_ms", "max_inference_time_ms",
+        "avg_fake_probability", "sentiments_distribution",
+    ]
+    with open(path, "w", newline="", encoding="utf-8") as fh:
+        writer = csv.DictWriter(fh, fieldnames=summary_fields, extrasaction="ignore")
+        writer.writeheader()
+        for row in results:
+            if "error" in row:
+                continue
+            flat = {k: row.get(k) for k in summary_fields}
+            # Rozkład sentymentów jako string JSON w komórce CSV
+            flat["sentiments_distribution"] = json.dumps(
+                row.get("sentiments_distribution", {}), ensure_ascii=False
+            )
+            writer.writerow(flat)
+
+
+def _summary_only(results: List[BenchmarkResult]) -> List[BenchmarkResult]:
+    """Zwraca wyniki bez pola per_text (lżejsza odpowiedź HTTP)."""
+    return [{k: v for k, v in r.items() if k != "per_text"} for r in results]
+
+
+# ---------------------------------------------------------------------------
+# Uruchomienie standalone
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="TruthScan NLP benchmark")
+    parser.add_argument(
+        "--adapters", default="roberta,xlm-roberta,norbert",
+        help="Przecinkowa lista adapterów (domyślnie: wszystkie)",
+    )
+    parser.add_argument(
+        "--langs", default="en,pl,no",
+        help="Przecinkowa lista języków (domyślnie: en,pl,no)",
+    )
+    parser.add_argument(
+        "--out-dir", default="benchmark_results",
+        help="Katalog wyjściowy dla plików JSON i CSV",
+    )
+    args = parser.parse_args()
+
+    adapter_names = [a.strip() for a in args.adapters.split(",")]
+    langs = [l.strip() for l in args.langs.split(",")]
+    out_dir = Path(args.out_dir)
+
+    print(f"Uruchamiam benchmark: adaptery={adapter_names}, języki={langs}")
+    results = run_benchmark(adapter_names=adapter_names, langs=langs)
+
+    json_path = out_dir / "benchmark.json"
+    csv_path = out_dir / "benchmark.csv"
+    export_json(results, json_path)
+    export_csv(results, csv_path)
+
+    print(f"Wyniki zapisane: {json_path}, {csv_path}")
+    for r in _summary_only(results):
+        if "error" in r:
+            print(f"  [{r['adapter_name']}] BŁĄD: {r['error']}")
+        else:
+            print(
+                f"  [{r['adapter_name']:12s} / {r['language']}] "
+                f"avg={r['avg_inference_time_ms']} ms  "
+                f"fake={r['avg_fake_probability']}%  "
+                f"sentiments={r['sentiments_distribution']}"
+            )

TruthScan AI_backend/app/config.py

@@ -0,0 +1,50 @@
+"""
+Centralna konfiguracja aplikacji oraz stałe wykorzystywane w wielu modułach.
+"""
+
+import os
+from pathlib import Path
+
+# Konfiguracja CORS
+CORS_ALLOW_ORIGINS = ["*"]
+CORS_ALLOW_CREDENTIALS = True
+CORS_ALLOW_METHODS = ["*"]
+CORS_ALLOW_HEADERS = ["*"]
+
+# Lista obsługiwanych źródeł RSS
+NEWS_FEEDS = {
+    # Angielskie
+    "BBC":          "https://feeds.bbci.co.uk/news/rss.xml",
+    "CNN":          "http://rss.cnn.com/rss/edition.rss",
+    "NYTimes":      "https://rss.nytimes.com/services/xml/rss/nyt/HomePage.xml",
+    "Guardian":     "https://www.theguardian.com/world/rss",
+    "AlJazeera":    "https://www.aljazeera.com/xml/rss/all.xml",
+    # Polskie
+    "Money":        "https://www.money.pl/rss/",
+    "PolsatNews":   "https://www.polsatnews.pl/rss/wszystkie.xml",
+    "GazetaPrawna": "https://www.gazetaprawna.pl/rss.xml",
+    "SpidersWeb":   "https://spidersweb.pl/feed",
+    "Bankier":      "https://www.bankier.pl/rss/wiadomosci.xml",
+    # Norweskie
+    "NRK":          "https://www.nrk.no/toppsaker.rss",
+    "VG":           "https://www.vg.no/rss/feed/?limit=10",
+    "Dagbladet":    "https://www.dagbladet.no/rss",
+    "Aftenposten":  "https://www.aftenposten.no/rss",
+}
+
+# Mapowanie wyników analizy sentymentu na etykiety językowe
+SENTIMENT_MAP = {
+    "negative": {"pl": "Negatywne", "en": "Negative", "no": "Negativt"},
+    "neutral":  {"pl": "Neutralne", "en": "Neutral",  "no": "Nøytralt"},
+    "positive": {"pl": "Pozytywne", "en": "Positive", "no": "Positivt"},
+}
+
+# Ścieżka do pliku z zapisanymi artykułami
+SAVED_FILE = Path("saved_articles.json")
+
+# Czas życia cache (sekundy)
+CACHE_TTL_SECONDS = 120
+
+# Konfiguracja Redis (jeśli używany jako backend cache)
+REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379")
+CACHE_TTL = 300

TruthScan AI_backend/app/main.py

@@ -0,0 +1,57 @@
+"""
+Główna konfiguracja i uruchomienie aplikacji FastAPI.
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.inmemory import InMemoryBackend
+
+# Konfiguracja CORS (źródła, metody, nagłówki itp.)
+from .config import (
+    CORS_ALLOW_ORIGINS,
+    CORS_ALLOW_CREDENTIALS,
+    CORS_ALLOW_METHODS,
+    CORS_ALLOW_HEADERS
+)
+
+# Routery aplikacji
+from .routes import misc, news, saved
+
+# Inicjalizacja aplikacji FastAPI
+app = FastAPI()
+
+# Middleware CORS – umożliwia dostęp do API z innych domen
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=CORS_ALLOW_ORIGINS,
+    allow_credentials=CORS_ALLOW_CREDENTIALS,
+    allow_methods=CORS_ALLOW_METHODS,
+    allow_headers=CORS_ALLOW_HEADERS,
+)
+
+# Logika wykonywana przy starcie aplikacji
+@app.on_event("startup")
+async def startup():
+    # Inicjalizacja cache w pamięci (np. do cache’owania newsów)
+    FastAPICache.init(InMemoryBackend(), prefix="news-cache")
+    print("✓ Cache initialized (5 minut TTL)")
+
+# Rejestracja routerów
+app.include_router(misc.router)
+app.include_router(news.router)
+app.include_router(saved.router)
+
+# Endpoint główny – informacja o stanie API
+@app.get("/")
+async def root():
+    return {
+        "message": "ThruScan API",
+        "status": "running",
+        "cached": True
+    }
+
+# Endpoint zdrowia – używany np. przez monitoring / load balancer
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}

TruthScan AI_backend/app/models.py

@@ -0,0 +1,16 @@
+"""
+Modele danych wykorzystywane do walidacji i serializacji artykułów.
+"""
+
+from pydantic import BaseModel
+
+
+class Article(BaseModel):
+    # Model artykułu wykorzystywany w komunikacji API
+    title: str
+    link: str
+    summary: str
+    published: str
+    sentiment: str
+    fake_probability: float
+    source: str

TruthScan AI_backend/app/nlp_service.py

@@ -0,0 +1,459 @@
+"""
+Serwis NLP z architekturą plug-in.
+
+Każdy model jest reprezentowany przez adapter dziedziczący z ModelAdapter.
+Publiczne API (analyze_news, analyze_news_batch) pozostaje niezmienione,
+więc routes/news.py nie wymaga modyfikacji.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Optional
+from concurrent.futures import ThreadPoolExecutor
+
+from transformers import pipeline
+
+from .config import SENTIMENT_MAP
+
+
+# ---------------------------------------------------------------------------
+# Klasa bazowa
+# ---------------------------------------------------------------------------
+
+class ModelAdapter(ABC):
+    """
+    Abstrakcyjny adapter modelu NLP.
+
+    Każdy konkretny adapter musi zaimplementować:
+      - analyze_sentiment(text) -> {"label": str, "score": float}
+      - analyze_fake_news(text) -> {"labels": List[str], "scores": List[float]}
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Unikalny identyfikator adaptera (np. 'roberta', 'xlm-roberta')."""
+        ...
+
+    @property
+    @abstractmethod
+    def supported_languages(self) -> List[str]:
+        """Kody języków obsługiwanych przez model (np. ['pl', 'en', 'no'])."""
+        ...
+
+    @abstractmethod
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        """
+        Analizuje sentyment tekstu.
+
+        Zwraca:
+            {"label": str, "score": float}
+            gdzie label to jedna z wartości: 'positive' | 'negative' | 'neutral'
+        """
+        ...
+
+    @abstractmethod
+    def analyze_fake_news(self, text: str) -> Dict[str, Any]:
+        """
+        Klasyfikuje tekst jako real/fake.
+
+        Zwraca:
+            {"labels": List[str], "scores": List[float]}
+        """
+        ...
+
+
+# ---------------------------------------------------------------------------
+# Adaptery
+# ---------------------------------------------------------------------------
+
+def _normalize_sentiment_label(raw_label: str) -> str:
+    """
+    Normalizuje etykietę sentymentu z modelu do jednego z trzech wariantów:
+    'positive' | 'negative' | 'neutral'.
+
+    Obsługuje różne konwencje nazewnictwa stosowane przez modele HuggingFace.
+    """
+    label = (raw_label or "").strip().lower()
+
+    _POSITIVE = {"positive", "pos", "label_2", "2", "very positive"}
+    _NEGATIVE = {"negative", "neg", "label_0", "0", "very negative"}
+
+    if label in _POSITIVE or label.startswith("pos"):
+        return "positive"
+    if label in _NEGATIVE or label.startswith("neg"):
+        return "negative"
+    return "neutral"
+
+
+class RoBERTaAdapter(ModelAdapter):
+    """
+    Adapter dla modeli anglojęzycznych (domyślny, zachowuje obecne zachowanie):
+      - sentyment : cardiffnlp/twitter-roberta-base-sentiment-latest
+      - fake news : facebook/bart-large-mnli (zero-shot)
+    """
+
+    def __init__(self) -> None:
+        self._sentiment_pipe = None
+        self._fake_pipe = None
+
+    def _load(self) -> None:
+        if self._sentiment_pipe is None:
+            self._sentiment_pipe = pipeline(
+                "text-classification",
+                model="cardiffnlp/twitter-roberta-base-sentiment-latest",
+                return_all_scores=False,
+            )
+        if self._fake_pipe is None:
+            self._fake_pipe = pipeline(
+                "zero-shot-classification",
+                model="facebook/bart-large-mnli",
+            )
+
+    @property
+    def name(self) -> str:
+        return "roberta"
+
+    @property
+    def supported_languages(self) -> List[str]:
+        return ["en"]
+
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        self._load()
+        result = self._sentiment_pipe(text)[0]
+        return {
+            "label": _normalize_sentiment_label(result.get("label", "")),
+            "score": float(result.get("score", 0.0)),
+        }
+
+    def analyze_fake_news(self, text: str) -> Dict[str, Any]:
+        self._load()
+        result = self._fake_pipe(text, candidate_labels=["real", "fake"])
+        return {"labels": result["labels"], "scores": result["scores"]}
+
+
+class XLMRoBERTaAdapter(ModelAdapter):
+    """
+    Adapter wielojęzyczny (pl, en, no):
+      - sentyment : cardiffnlp/twitter-xlm-roberta-base-sentiment
+      - fake news : facebook/bart-large-mnli (zero-shot, transfer między językami)
+    """
+
+    def __init__(self) -> None:
+        self._sentiment_pipe = None
+        self._fake_pipe = None
+
+    def _load(self) -> None:
+        if self._sentiment_pipe is None:
+            self._sentiment_pipe = pipeline(
+                "text-classification",
+                model="cardiffnlp/twitter-xlm-roberta-base-sentiment",
+                return_all_scores=False,
+            )
+        if self._fake_pipe is None:
+            self._fake_pipe = pipeline(
+                "zero-shot-classification",
+                model="facebook/bart-large-mnli",
+            )
+
+    @property
+    def name(self) -> str:
+        return "xlm-roberta"
+
+    @property
+    def supported_languages(self) -> List[str]:
+        return ["pl", "en", "no"]
+
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        self._load()
+        result = self._sentiment_pipe(text)[0]
+        return {
+            "label": _normalize_sentiment_label(result.get("label", "")),
+            "score": float(result.get("score", 0.0)),
+        }
+
+    def analyze_fake_news(self, text: str) -> Dict[str, Any]:
+        self._load()
+        result = self._fake_pipe(text, candidate_labels=["real", "fake"])
+        return {"labels": result["labels"], "scores": result["scores"]}
+
+
+class HerBERTAdapter(ModelAdapter):
+    """
+    Adapter dla języka polskiego (HerBERT):
+      - sentyment : allegro/herbert-base-cased
+        UWAGA: to model bazowy – wymaga fine-tuningu na zbiorze sentymentu
+        (np. PolEmo 2.0). Aby podmienić checkpoint, przekaż sentiment_model
+        w konstruktorze lub zmień SENTIMENT_MODEL przed pierwszym użyciem.
+      - fake news : facebook/bart-large-mnli (zero-shot, transfer EN→PL)
+    """
+
+    SENTIMENT_MODEL: str = "allegro/herbert-base-cased"
+
+    def __init__(self, sentiment_model: Optional[str] = None) -> None:
+        self._sentiment_model_id = sentiment_model or self.SENTIMENT_MODEL
+        self._sentiment_pipe = None
+        self._fake_pipe = None
+
+    def _load(self) -> None:
+        if self._sentiment_pipe is None:
+            self._sentiment_pipe = pipeline(
+                "text-classification",
+                model=self._sentiment_model_id,
+                return_all_scores=False,
+            )
+        if self._fake_pipe is None:
+            self._fake_pipe = pipeline(
+                "zero-shot-classification",
+                model="facebook/bart-large-mnli",
+            )
+
+    @property
+    def name(self) -> str:
+        return "herbert"
+
+    @property
+    def supported_languages(self) -> List[str]:
+        return ["pl"]
+
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        self._load()
+        result = self._sentiment_pipe(text)[0]
+        return {
+            "label": _normalize_sentiment_label(result.get("label", "")),
+            "score": float(result.get("score", 0.0)),
+        }
+
+    def analyze_fake_news(self, text: str) -> Dict[str, Any]:
+        self._load()
+        result = self._fake_pipe(text, candidate_labels=["real", "fake"])
+        return {"labels": result["labels"], "scores": result["scores"]}
+
+
+class NorBERTAdapter(ModelAdapter):
+    """
+    Adapter dla języka norweskiego (NorBERT 3):
+      - sentyment : ltgoslo/norbert3-base
+        UWAGA: to model bazowy – wymaga fine-tuningu na zbiorze sentymentu
+        (np. NoReC). Aby podmienić checkpoint, przekaż sentiment_model
+        w konstruktorze lub zmień SENTIMENT_MODEL przed pierwszym użyciem.
+      - fake news : facebook/bart-large-mnli (zero-shot, transfer EN→NO)
+    """
+
+    SENTIMENT_MODEL: str = "ltgoslo/norbert3-base"
+
+    def __init__(self, sentiment_model: Optional[str] = None) -> None:
+        self._sentiment_model_id = sentiment_model or self.SENTIMENT_MODEL
+        self._sentiment_pipe = None
+        self._fake_pipe = None
+
+    def _load(self) -> None:
+        if self._sentiment_pipe is None:
+            self._sentiment_pipe = pipeline(
+                "text-classification",
+                model=self._sentiment_model_id,
+                return_all_scores=False,
+            )
+        if self._fake_pipe is None:
+            self._fake_pipe = pipeline(
+                "zero-shot-classification",
+                model="facebook/bart-large-mnli",
+            )
+
+    @property
+    def name(self) -> str:
+        return "norbert"
+
+    @property
+    def supported_languages(self) -> List[str]:
+        return ["no"]
+
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        self._load()
+        result = self._sentiment_pipe(text)[0]
+        return {
+            "label": _normalize_sentiment_label(result.get("label", "")),
+            "score": float(result.get("score", 0.0)),
+        }
+
+    def analyze_fake_news(self, text: str) -> Dict[str, Any]:
+        self._load()
+        result = self._fake_pipe(text, candidate_labels=["real", "fake"])
+        return {"labels": result["labels"], "scores": result["scores"]}
+
+
+# ---------------------------------------------------------------------------
+# Rejestr adapterów — lazy initialization
+# ---------------------------------------------------------------------------
+
+# Przy imporcie pusty — żaden adapter nie jest tworzony ani ładowany.
+# Adaptery są instancjonowane dopiero przy pierwszym wywołaniu get_adapter().
+_REGISTRY: Dict[str, ModelAdapter] = {}
+
+# Adapter aktywny globalnie; None oznacza „jeszcze nie wybrano".
+_active_adapter: Optional[ModelAdapter] = None
+
+# Executor do równoległej analizy (ograniczenie obciążenia CPU)
+executor = ThreadPoolExecutor(max_workers=3)
+
+# Zbiór nazw wbudowanych adapterów — służy do walidacji przed inicjalizacją
+_BUILTIN_ADAPTERS = {"roberta", "xlm-roberta", "herbert", "norbert"}
+
+
+def _init_registry() -> None:
+    """
+    Tworzy wbudowane adaptery i wpisuje je do rejestru.
+
+    Wywoływana leniwie przy pierwszym get_adapter() lub set_active_adapter().
+    Kolejne wywołania są bezoperacyjne (idempotentna).
+    """
+    if _REGISTRY:
+        return
+    _REGISTRY["roberta"]     = RoBERTaAdapter()
+    _REGISTRY["xlm-roberta"] = XLMRoBERTaAdapter()
+    _REGISTRY["herbert"]     = HerBERTAdapter()
+    _REGISTRY["norbert"]     = NorBERTAdapter()
+
+
+def get_adapter(name: str) -> ModelAdapter:
+    """
+    Zwraca adapter o podanej nazwie.
+
+    Przy pierwszym wywołaniu inicjalizuje rejestr (bez ładowania wag modeli).
+    Rzuca ValueError dla nieznanej nazwy.
+    """
+    _init_registry()
+    if name not in _REGISTRY:
+        raise ValueError(
+            f"Nieznany adapter: '{name}'. Dostępne: {list(_REGISTRY.keys())}"
+        )
+    return _REGISTRY[name]
+
+
+def set_active_adapter(name: str) -> None:
+    """
+    Ustawia aktywny adapter dla całej aplikacji.
+
+    Przykład:
+        from app.nlp_service import set_active_adapter
+        set_active_adapter("xlm-roberta")
+    """
+    global _active_adapter
+    _active_adapter = get_adapter(name)
+
+
+def register_adapter(adapter: ModelAdapter) -> None:
+    """
+    Rejestruje nowy adapter (np. fine-tuned checkpoint) pod jego nazwą.
+    Może być wywołane przed lub po _init_registry().
+
+    Przykład:
+        norbert_ft = NorBERTAdapter(sentiment_model="user/norbert3-norec")
+        register_adapter(norbert_ft)
+        set_active_adapter("norbert")
+    """
+    _init_registry()
+    _REGISTRY[adapter.name] = adapter
+
+
+def _get_active_adapter() -> ModelAdapter:
+    """
+    Zwraca aktualnie aktywny adapter.
+    Jeśli nie ustawiono, domyślnie inicjalizuje i zwraca RoBERTaAdapter.
+    """
+    global _active_adapter
+    if _active_adapter is None:
+        _active_adapter = get_adapter("roberta")
+    return _active_adapter
+
+
+# ---------------------------------------------------------------------------
+# Publiczne API – interfejs niezmieniony względem poprzedniej wersji
+# ---------------------------------------------------------------------------
+
+def analyze_news(
+    text: str,
+    lang: str = "pl",
+    adapter: Optional[ModelAdapter] = None,
+) -> dict:
+    """
+    Analizuje pojedynczy tekst pod kątem sentymentu i fake news.
+
+    Args:
+        text:    Tekst do analizy.
+        lang:    Kod języka wynikowych etykiet ('pl' | 'en' | 'no').
+        adapter: Opcjonalny adapter; jeśli None, używa _active_adapter.
+
+    Returns:
+        {"sentiment": str, "fake_probability": float, "sentiment_score": float}
+    """
+    _neutral = SENTIMENT_MAP["neutral"].get(lang, "Neutral")
+
+    if not text or len(text.strip()) < 10:
+        return {"sentiment": _neutral, "fake_probability": 0.0, "sentiment_score": 0.0}
+
+    _adapter = adapter or _get_active_adapter()
+
+    try:
+        sentiment_result = _adapter.analyze_sentiment(text)
+        fake_result = _adapter.analyze_fake_news(text)
+    except Exception:
+        return {"sentiment": _neutral, "fake_probability": 0.0, "sentiment_score": 0.0}
+
+    label = sentiment_result.get("label", "neutral")
+    sentiment_translated = SENTIMENT_MAP.get(label, {}).get(lang, _neutral)
+
+    fake_score = 0.0
+    for lbl, score in zip(fake_result["labels"], fake_result["scores"]):
+        if lbl == "fake":
+            fake_score = score
+            break
+
+    return {
+        "sentiment": sentiment_translated,
+        "fake_probability": round(fake_score * 100, 2),
+        "sentiment_score": round(float(sentiment_result.get("score", 0.0)), 2),
+    }
+
+
+def analyze_news_batch(
+    texts: List[str],
+    lang: str = "pl",
+    adapter: Optional[ModelAdapter] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Analiza wielu tekstów w trybie batch z użyciem ThreadPoolExecutor.
+
+    Args:
+        texts:   Lista tekstów do analizy.
+        lang:    Kod języka wynikowych etykiet.
+        adapter: Opcjonalny adapter; jeśli None, używa _active_adapter.
+    """
+    if not texts:
+        return []
+
+    _adapter = adapter or _get_active_adapter()
+    results: List[Dict[str, Any]] = []
+    batch_size = 3
+
+    batches = [texts[i:i + batch_size] for i in range(0, len(texts), batch_size)]
+
+    for batch in batches:
+        futures = [
+            executor.submit(analyze_news, text, lang, _adapter)
+            for text in batch
+        ]
+        for future in futures:
+            try:
+                results.append(future.result())
+            except Exception:
+                _neutral = SENTIMENT_MAP["neutral"].get(lang, "Neutral")
+                results.append(
+                    {"sentiment": _neutral, "fake_probability": 0.0, "sentiment_score": 0.0}
+                )
+
+    return results
+
+
+def analyze_news_single(text: str, lang: str) -> Dict[str, Any]:
+    """Wrapper dla analizy pojedynczego tekstu (używany w batch processing)."""
+    return analyze_news(text, lang)

TruthScan AI_backend/app/routes/misc.py

@@ -0,0 +1,68 @@
+"""
+Endpointy związane z obsługą dostępnych źródeł wiadomości oraz narzędziami deweloperskimi.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, Query
+
+from ..config import NEWS_FEEDS
+from ..benchmark import run_benchmark, export_json, export_csv, _summary_only
+
+router = APIRouter()
+
+# Katalog, do którego endpoint zapisuje artefakty benchmarku
+_BENCHMARK_OUT = Path("benchmark_results")
+
+
+@router.get("/sources")
+def get_sources():
+    return list(NEWS_FEEDS.keys())
+
+
+@router.get("/benchmark")
+def benchmark(
+    adapters: Optional[str] = Query(
+        default=None,
+        description="Przecinkowa lista adapterów: roberta,xlm-roberta,norbert",
+    ),
+    langs: Optional[str] = Query(
+        default=None,
+        description="Przecinkowa lista języków: en,pl,no",
+    ),
+    save: bool = Query(
+        default=True,
+        description="Czy zapisać wyniki do JSON i CSV w katalogu benchmark_results/",
+    ),
+    full: bool = Query(
+        default=False,
+        description="Czy zwrócić szczegółowe wyniki per_text (domyślnie tylko podsumowanie)",
+    ),
+):
+    """
+    Uruchamia benchmark NLP i zwraca wyniki.
+
+    Czas odpowiedzi zależy od liczby adapterów i języków — może wynosić kilkadziesiąt sekund
+    przy pierwszym uruchomieniu (lazy-loading modeli HuggingFace).
+
+    Przykłady:
+    - GET /benchmark
+    - GET /benchmark?adapters=roberta,xlm-roberta&langs=en,pl
+    - GET /benchmark?full=true&save=false
+    """
+    adapter_names = [a.strip() for a in adapters.split(",")] if adapters else None
+    lang_list = [l.strip() for l in langs.split(",")] if langs else None
+
+    results = run_benchmark(adapter_names=adapter_names, langs=lang_list)
+
+    if save:
+        export_json(results, _BENCHMARK_OUT / "benchmark.json")
+        export_csv(results, _BENCHMARK_OUT / "benchmark.csv")
+
+    return {
+        "results": results if full else _summary_only(results),
+        "saved": save,
+        "output_dir": str(_BENCHMARK_OUT) if save else None,
+    }
+

TruthScan AI_backend/app/routes/news.py

@@ -0,0 +1,234 @@
+"""
+Endpointy związane z pobieraniem, analizą i strumieniowaniem wiadomości.
+"""
+
+import asyncio
+import json
+from typing import List
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi_cache.decorator import cache
+
+from ..config import CACHE_TTL, NEWS_FEEDS
+from ..rss_utils import fetch_feed, clean_html, get_from_cache, set_to_cache
+from ..nlp_service import analyze_news
+
+router = APIRouter()
+
+
+@router.get("/news/{source}")
+def get_news(source: str, lang: str = "pl"):
+    # Walidacja źródła
+    if source not in NEWS_FEEDS:
+        raise HTTPException(status_code=404, detail="Źródło nieobsługiwane")
+
+    url = NEWS_FEEDS[source]
+
+    # Pobranie RSS
+    try:
+        feed = fetch_feed(url)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Błąd pobierania newsów: {str(e)}")
+
+    if not feed.entries:
+        return {"source": source, "articles": []}
+
+    MAX_ARTICLES = 5
+    articles: List[dict] = []
+
+    # Przetwarzanie i analiza artykułów
+    for entry in feed.entries[:MAX_ARTICLES]:
+        summary = clean_html(entry.get("summary", "Brak opisu"))
+        text_to_analyze = (summary or "").strip() or entry.get("title", "")
+        analysis = analyze_news(text_to_analyze, lang)
+
+        articles.append({
+            "title": entry.get("title", "Bez tytułu"),
+            "link": entry.get("link", ""),
+            "summary": summary,
+            "published": entry.get("published", "Brak daty"),
+            "source": source,
+            **analysis
+        })
+
+    return {"source": source, "articles": articles}
+
+
+# Strumieniowanie newsów przez SSE
+@router.get("/stream-news/{source}")
+async def stream_news(source: str, lang: str = "pl"):
+    if source not in NEWS_FEEDS:
+        raise HTTPException(status_code=404, detail="Źródło nieobsługiwane")
+
+    async def event_generator():
+        # Próba pobrania RSS z cache
+        try:
+            cached = get_from_cache(source)
+            if cached:
+                feed = cached
+            else:
+                feed = fetch_feed(NEWS_FEEDS[source])
+                set_to_cache(source, feed)
+        except Exception as e:
+            yield f"event: backend_error\ndata: {json.dumps({'message': str(e)})}\n\n"
+            yield f"event: done\ndata: {json.dumps({'count': 0})}\n\n"
+            return
+
+        entries = feed.entries or []
+        MAX_ARTICLES = 5
+        to_send = entries[:MAX_ARTICLES]
+
+        # Metadane dla klienta
+        yield f"event: meta\ndata: {json.dumps({'total': len(to_send)})}\n\n"
+
+        sent = 0
+        for entry in to_send:
+            summary = clean_html(entry.get("summary", "Brak opisu"))
+            text_to_analyze = (summary or "").strip() or entry.get("title", "")
+
+            # Analiza NLP uruchamiana w executorze (CPU-bound)
+            loop = asyncio.get_event_loop()
+            analysis = await loop.run_in_executor(
+                None, lambda: analyze_news(text_to_analyze, lang)
+            )
+
+            article = {
+                "title": entry.get("title", "Bez tytułu"),
+                "link": entry.get("link", ""),
+                "summary": summary,
+                "published": entry.get("published", "Brak daty"),
+                "source": source,
+                **analysis,
+            }
+
+            yield f"data: {json.dumps(article, ensure_ascii=False)}\n\n"
+            sent += 1
+            await asyncio.sleep(0.3)
+
+        yield f"event: done\ndata: {json.dumps({'count': sent})}\n\n"
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+
+@router.get("/api/charts/summary")
+@cache(expire=CACHE_TTL)
+async def get_charts_summary(lang: str = "pl"):
+    """
+    Szybkie statystyki zbiorcze dla wszystkich źródeł
+    (uproszczona analiza oparta na tytułach).
+    """
+    sources = [
+        "BBC", "CNN", "NYTimes", "Guardian", "AlJazeera",
+        "PolsatNews", "Money", "Bankier", "SpidersWeb", "GazetaPrawna"
+    ]
+
+    summary_data = {}
+
+    for source in sources:
+        if source not in NEWS_FEEDS:
+            continue
+
+        try:
+            feed = fetch_feed(NEWS_FEEDS[source])
+
+            if not feed.entries:
+                summary_data[source] = {
+                    "count": 0,
+                    "emotions": {"Pozytywne": 0, "Negatywne": 0, "Neutralne": 0}
+                }
+                continue
+
+            # Analiza tylko kilku tytułów (szybko)
+            articles = feed.entries[:3]
+            emotion_counts = {"Pozytywne": 0, "Negatywne": 0, "Neutralne": 0}
+
+            for entry in articles:
+                title = entry.get("title", "").lower()
+                if any(word in title for word in ["good", "positive", "gain", "up", "success", "dobry", "wzrost", "zysk"]):
+                    emotion_counts["Pozytywne"] += 1
+                elif any(word in title for word in ["bad", "negative", "fall", "down", "loss", "crisis", "zły", "spadek", "kryzys"]):
+                    emotion_counts["Negatywne"] += 1
+                else:
+                    emotion_counts["Neutralne"] += 1
+
+            summary_data[source] = {
+                "count": len(feed.entries),
+                "analyzed": len(articles),
+                "emotions": emotion_counts,
+                "latest_title": articles[0].get("title", "")[:50] if articles else ""
+            }
+
+        except Exception:
+            summary_data[source] = {
+                "count": 0,
+                "emotions": {"Pozytywne": 0, "Negatywne": 0, "Neutralne": 0}
+            }
+
+    return {
+        "summary": summary_data,
+        "total_sources": len(summary_data),
+        "cache_ttl": CACHE_TTL
+    }
+
+
+@router.get("/emotion-stats/{source}")
+@cache(expire=CACHE_TTL)
+def get_emotion_stats(source: str, lang: str = "pl"):
+    # Statystyki emocji dla jednego źródła
+    if source not in NEWS_FEEDS:
+        raise HTTPException(status_code=404, detail="Źródło nieobsługiwane")
+
+    try:
+        news_data = get_news(source, lang)
+        articles = news_data.get("articles", [])
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Błąd generowania statystyk: {str(e)}")
+
+    emotion_counts = {"Pozytywne": 0, "Negatywne": 0, "Neutralne": 0}
+
+    for article in articles:
+        sentiment = article.get("sentiment", "Neutralne")
+        if sentiment in emotion_counts:
+            emotion_counts[sentiment] += 1
+
+    total = len(articles)
+    emotion_percentages = {
+        emotion: (round((count / total) * 100, 2) if total > 0 else 0)
+        for emotion, count in emotion_counts.items()
+    }
+
+    return {
+        "source": source,
+        "total_articles": total,
+        "emotion_counts": emotion_counts,
+        "emotion_percentages": emotion_percentages
+    }
+
+
+@router.get("/charts-data")
+@cache(expire=CACHE_TTL)
+async def get_all_charts_data(lang: str = "pl"):
+    """
+    Kompatybilność ze starszym frontendem – agreguje dane ze wszystkich źródeł.
+    """
+    sources = [
+        "BBC", "CNN", "NYTimes", "Guardian", "AlJazeera",
+        "PolsatNews", "Money", "Bankier", "SpidersWeb", "GazetaPrawna"
+    ]
+
+    async def fetch_stats(source):
+        try:
+            return {source: await get_emotion_stats(source, lang)}
+        except Exception:
+            return {source: None}
+
+    tasks = [fetch_stats(source) for source in sources]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    all_data = {}
+    for result in results:
+        if isinstance(result, dict):
+            all_data.update(result)
+
+    return {"charts": all_data}

TruthScan AI_backend/app/routes/saved.py

@@ -0,0 +1,34 @@
+"""
+Endpointy związane z zapisywaniem i zarządzaniem zapisanymi artykułami.
+"""
+
+from fastapi import APIRouter, HTTPException, Request
+
+from ..storage import read_all, append_article, delete_by_title
+from ..models import Article
+
+router = APIRouter()
+
+
+@router.get("/saved-articles")
+def get_saved_articles():
+    # Zwraca listę wszystkich zapisanych artykułów
+    return read_all()
+
+
+@router.post("/save-article")
+def save_article(article: Article):
+    # Zapisuje nowy artykuł do magazynu danych
+    return append_article(article.dict())
+
+
+@router.delete("/delete-article")
+async def delete_article(request: Request):
+    # Usuwa artykuł na podstawie tytułu przekazanego w body requestu
+    data = await request.json()
+    title = data.get("title")
+
+    if not title:
+        raise HTTPException(status_code=400, detail="Brak pola 'title'")
+
+    return delete_by_title(title)

TruthScan AI_backend/app/rss_utils.py

@@ -0,0 +1,47 @@
+"""
+Narzędzia pomocnicze do pobierania i przetwarzania kanałów RSS oraz cache w pamięci.
+"""
+
+import time
+import requests
+import feedparser
+from bs4 import BeautifulSoup
+from typing import Dict, Any
+
+from .config import CACHE_TTL_SECONDS
+
+# Prosty cache w pamięci (key -> (value, timestamp))
+_cache_data: Dict[str, tuple[Any, float]] = {}
+
+
+def clean_html(text: str) -> str:
+    # Usuwa znaczniki HTML z treści RSS
+    return BeautifulSoup(text or "", "html.parser").get_text()
+
+
+def get_from_cache(key: str):
+    # Pobiera dane z cache, jeśli nie przekroczyły TTL
+    entry = _cache_data.get(key)
+    if not entry:
+        return None
+
+    value, ts = entry
+    if time.time() - ts > CACHE_TTL_SECONDS:
+        del _cache_data[key]
+        return None
+
+    return value
+
+
+def set_to_cache(key: str, value):
+    # Zapisuje dane do cache wraz z timestampem
+    _cache_data[key] = (value, time.time())
+
+
+def fetch_feed(url: str):
+    # Pobiera i parsuje kanał RSS z ustawionym User-Agent
+    headers = {"User-Agent": "Mozilla/5.0 (compatible; ThruScanBot/1.0)"}
+    resp = requests.get(url, timeout=7, headers=headers)
+    resp.raise_for_status()
+
+    return feedparser.parse(resp.content)

TruthScan AI_backend/app/storage.py

@@ -0,0 +1,60 @@
+"""
+Warstwa dostępu do danych dla zapisanych artykułów (plik JSON).
+"""
+
+import json
+import threading
+from fastapi import HTTPException
+
+from .config import SAVED_FILE
+
+# Blokada wątków dla operacji zapisu/odczytu
+_lock = threading.Lock()
+
+
+def ensure_file():
+    # Tworzy plik danych, jeśli nie istnieje
+    if not SAVED_FILE.exists():
+        SAVED_FILE.write_text("[]", encoding="utf-8")
+
+
+def read_all():
+    # Zwraca wszystkie zapisane artykuły
+    ensure_file()
+    try:
+        return json.loads(SAVED_FILE.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return []
+
+
+def append_article(article: dict):
+    # Dodaje nowy artykuł do pliku JSON
+    ensure_file()
+    try:
+        with _lock, open(SAVED_FILE, "r+", encoding="utf-8") as f:
+            data = json.load(f)
+            data.append(article)
+            f.seek(0)
+            json.dump(data, f, ensure_ascii=False, indent=4)
+
+        return {"message": "Artykuł zapisany pomyślnie."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+def delete_by_title(title: str):
+    # Usuwa artykuł na podstawie tytułu
+    ensure_file()
+    try:
+        with _lock, open(SAVED_FILE, "r+", encoding="utf-8") as f:
+            saved = json.load(f)
+            new_saved = [
+                a for a in saved if a.get("title") != title
+            ]
+            f.seek(0)
+            f.truncate()
+            json.dump(new_saved, f, ensure_ascii=False, indent=4)
+
+        return {"message": "Artykuł usunięty."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

TruthScan AI_backend/requirements.txt

@@ -0,0 +1,22 @@
+# Zależności backendu aplikacji ThruScan
+
+# Framework API i serwer ASGI
+fastapi==0.115.12
+uvicorn==0.34.3
+starlette==0.46.2
+
+# Walidacja danych i modele
+pydantic==2.11.7
+pydantic_core==2.33.2
+annotated-types==0.7.0
+typing-extensions>=4.12.2
+
+# NLP i uczenie maszynowe
+transformers==4.44.2
+tokenizers==0.19.1
+torch==2.3.1
+
+# Przetwarzanie RSS i HTML
+feedparser==6.0.11
+beautifulsoup4==4.12.3
+requests==2.31.0

TruthScan AI_backend/setup_test_env.bat

@@ -0,0 +1,21 @@
+@echo off
+echo ========================================
+echo 🛠  Przygotowanie środowiska testowego
+echo ========================================
+
+echo.
+echo 📦 Instalowanie wymaganych bibliotek...
+pip install requests pandas
+
+echo.
+echo 🔍 Sprawdzanie czy backend działa...
+timeout /t 3 /nobreak > nul
+
+echo.
+echo 🚀 Uruchamianie testów...
+python test_truthscan.py
+
+echo.
+echo 📊 Testy zakończone!
+echo Otwórz raport: truthscan_test_report.html
+pause

TruthScan AI_backend/truthscan_report.html

@@ -0,0 +1,417 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Raport porównawczy TruthScan AI - BBC vs Gazeta Prawna</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        body { 
+            font-family: 'Segoe UI', Arial, sans-serif; 
+            margin: 0; 
+            padding: 20px; 
+            background: #f0f2f5;
+        }
+        .container { 
+            max-width: 1200px; 
+            margin: 0 auto; 
+            background: white; 
+            padding: 30px; 
+            border-radius: 10px; 
+            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+        }
+        h1 { 
+            color: #2c3e50; 
+            text-align: center; 
+            margin-bottom: 20px; 
+            border-bottom: 3px solid #3498db;
+            padding-bottom: 10px;
+        }
+        .header { 
+            text-align: center; 
+            margin-bottom: 30px; 
+        }
+        .test-date { 
+            color: #7f8c8d; 
+            font-size: 1em; 
+            margin-top: 5px;
+        }
+        
+        .comparison-section { 
+            display: grid; 
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); 
+            gap: 20px; 
+            margin-bottom: 30px;
+        }
+        .comparison-card { 
+            background: #fff; 
+            padding: 20px; 
+            border-radius: 8px; 
+            box-shadow: 0 2px 10px rgba(0,0,0,0.08);
+            border-left: 4px solid #3498db;
+        }
+        .comparison-card h3 { 
+            color: #2c3e50; 
+            margin-top: 0;
+        }
+        
+        .chart-container { 
+            position: relative; 
+            height: 250px; 
+            margin: 15px 0;
+        }
+        
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin: 20px 0;
+        }
+        .stat-box { 
+            padding: 15px;
+            border-radius: 6px;
+            color: white;
+            text-align: center;
+        }
+        .bbc-stat { 
+            background: linear-gradient(135deg, #e74c3c, #c0392b);
+        }
+        .gazeta-stat { 
+            background: linear-gradient(135deg, #27ae60, #229954);
+        }
+        
+        .source-details { 
+            background: #ecf0f1; 
+            padding: 15px; 
+            border-radius: 6px; 
+            margin: 20px 0;
+        }
+        
+        .results-table { 
+            width: 100%; 
+            border-collapse: collapse; 
+            margin-top: 20px;
+        }
+        .results-table th, .results-table td { 
+            padding: 12px; 
+            text-align: left; 
+            border-bottom: 1px solid #ddd;
+        }
+        .results-table th { 
+            background-color: #3498db; 
+            color: white;
+        }
+        .results-table tr:hover { 
+            background-color: #f5f5f5;
+        }
+        
+        .pass { color: #27ae60; font-weight: bold; }
+        .fail { color: #e74c3c; font-weight: bold; }
+        .warn { color: #f39c12; font-weight: bold; }
+        
+        .insights { 
+            background: #2c3e50; 
+            color: white; 
+            padding: 20px; 
+            border-radius: 8px; 
+            margin-top: 30px;
+        }
+        
+        .footer { 
+            text-align: center; 
+            margin-top: 30px; 
+            color: #7f8c8d; 
+            font-size: 0.9em;
+            border-top: 1px solid #ecf0f1;
+            padding-top: 15px;
+        }
+        
+        .highlight { 
+            background: #fff3cd;
+            padding: 10px;
+            border-radius: 5px;
+            border-left: 4px solid #ffc107;
+            margin: 15px 0;
+        }
+        .conclusions { 
+            background: #2c3e50; 
+            color: white; 
+            padding: 20px; 
+            border-radius: 8px; 
+            margin-top: 30px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>📊 RAPORT PORÓWNAWCZY TRUTHSCAN AI</h1>
+            <h2>BBC vs Gazeta Prawna - Analiza systemu detekcji dezinformacji</h2>
+            <div class="test-date">Data testów: 20.12.2025 08:56:33</div>
+        </div>
+        
+        <div class="stats-grid">
+            <div class="stat-box bbc-stat">
+                <h3>BBC</h3>
+                <p>Artykułów: 5</p>
+                <p>Fake: 25.5%</p>
+                <p>Czas: 5.22s</p>
+            </div>
+            <div class="stat-box gazeta-stat">
+                <h3>Gazeta Prawna</h3>
+                <p>Artykułów: 5</p>
+                <p>Fake: 17.2%</p>
+                <p>Czas: 15.03s</p>
+            </div>
+        </div>
+        
+        <div class="comparison-section">
+            <div class="comparison-card">
+                <h3>📈 Średnie ryzyko dezinformacji</h3>
+                <div class="chart-container">
+                    <canvas id="fakeScoreChart"></canvas>
+                </div>
+            </div>
+            
+            <div class="comparison-card">
+                <h3>⚡ Wydajność systemu</h3>
+                <div class="chart-container">
+                    <canvas id="performanceChart"></canvas>
+                </div>
+            </div>
+        </div>
+        
+        <div class="comparison-section">
+            <div class="comparison-card">
+                <h3>🎭 Rozkład sentymentu - BBC</h3>
+                <div class="chart-container">
+                    <canvas id="bbcSentimentChart"></canvas>
+                </div>
+            </div>
+            
+            <div class="comparison-card">
+                <h3>🎭 Rozkład sentymentu - Gazeta Prawna</h3>
+                <div class="chart-container">
+                    <canvas id="gazetaSentimentChart"></canvas>
+                </div>
+            </div>
+        </div>
+        
+        <div class="highlight">
+            <h4>🔍 Kluczowe różnice:</h4>
+            <p>• Różnica w ryzyku dezinformacji: <strong>8.3%</strong></p>
+            <p>• Różnica w czasie analizy: <strong>9.81s</strong></p>
+            <p style='color: #27ae60;'>• ✅ Spójna skuteczność detekcji między językami</p>
+        </div>
+        
+        <div class="source-details">
+            <h4>📰 Przykładowe artykuły z analizą</h4>
+            
+            <h5>BBC:</h5><p><strong>1.</strong> Who and what is in the Epstein files?...</p><p><strong>2.</strong> David Walliams denies inappropriate behaviour after publisher drops him...</p>
+            <h5>Gazeta Prawna:</h5><p><strong>1.</strong> Fałszywe oskarżenia na policji mogą zrujnować życie – sprawdź, kiedy grozi za ni...</p><p><strong>2.</strong> Polacy za granicą: w tym kraju mieszka ich tylko dwoje. Zamiast polskiej zimy ma...</p>
+        </div>
+        
+        <h3>📋 Wyniki testów (7/7 przepuszczonych)</h3>
+        <table class="results-table">
+            <thead>
+                <tr>
+                    <th>Test</th>
+                    <th>Status</th>
+                    <th>Szczegóły</th>
+                    <th>Czas [s]</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td>API Availability</td>
+                    <td class="pass">✅ PASS</td>
+                    <td>Swagger UI dostępny (200)</td>
+                    <td>2.07</td>
+                </tr>
+                <tr>
+                    <td>GET /sources</td>
+                    <td class="pass">✅ PASS</td>
+                    <td>Znaleziono 10 źródeł | ✅ BBC dostępne | ✅ Gazeta Prawna dostępne</td>
+                    <td>2.06</td>
+                </tr>
+                <tr>
+                    <td>GET /news/BBC</td>
+                    <td class="pass">✅ PASS</td>
+                    <td>Pobrano 5 artykułów | Źródło: BBC | Pola: title, sentiment, fake_probability, summary, link, published | Przykład: 'Who and what is in the Epstein files?'</td>
+                    <td>5.22</td>
+                </tr>
+                <tr>
+                    <td>GET /news/GazetaPrawna</td>
+                    <td class="pass">✅ PASS</td>
+                    <td>Pobrano 5 artykułów | Źródło: GazetaPrawna | Pola: title, sentiment, fake_probability, summary, link, published | Przykład: 'Fałszywe oskarżenia na policji mogą zrujnować życi...'</td>
+                    <td>15.03</td>
+                </tr>
+                <tr>
+                    <td>Source Comparison</td>
+                    <td class="pass">✅ PASS</td>
+                    <td>BBC: 5 art, 25.5% fake, 5.2s | Gazeta: 5 art, 17.2% fake, 15.0s</td>
+                    <td>-</td>
+                </tr>
+                <tr>
+                    <td>CRUD Operations - BBC</td>
+                    <td class="pass">✅ PASS</td>
+                    <td>Zapis: ✅ (2.07s) | Odczyt: ✅ (15 artykułów, 2.09s) | Usuwanie: ✅ (Status: 200)</td>
+                    <td>-</td>
+                </tr>
+                <tr>
+                    <td>CRUD Operations - GazetaPrawna</td>
+                    <td class="pass">✅ PASS</td>
+                    <td>Zapis: ✅ (2.06s) | Odczyt: ✅ (15 artykułów, 2.11s) | Usuwanie: ✅ (Status: 200)</td>
+                    <td>-</td>
+                </tr>
+            </tbody>
+        </table>
+        
+        <div class="conclusions">
+            <h4>Wnioski i rekomendacje</h4>
+            
+            <h5>Kluczowe wnioski:</h5>
+            <ul>
+                <li>System skutecznie analizuje źródła anglojęzyczne i polskojęzyczne</li>
+                <li>Analiza treści polskich zajmuje więcej czasu: różnica 12.91s</li>
+                <li>Różnica w wykrywaniu dezinformacji między źródłami: 0.1%</li>
+                <li>Spójna skuteczność detekcji między językami</li>
+            </ul>
+            
+            <h5>Rekomendacje:</h5>
+            <ol>
+                <li>Fine-tuning modeli NLP na polskich danych fact-checkingowych</li>
+                <li>Optymalizacja parsowania polskich znaków diakrytycznych</li>
+                <li>Implementacja cache'owania wyników dla często analizowanych źródeł</li>
+                <li>Rozszerzenie testów o więcej polskich źródeł informacji</li>
+                <li>Przeprowadzenie testów z rzeczywistymi użytkownikami</li>
+            </ol>
+        </div>
+    </div>
+    
+    <div class="footer">
+        <p>Raport wygenerowany automatycznie przez TruthScan AI Comparative Tester</p>
+        <p>System TruthScan AI - Prototyp do walki z dezinformacją</p>
+        <p>Wskaźnik sukcesu testów: 100.0% | Błędy: 0</p>
+    </div>
+</div>
+
+<script>
+    // Wykres ryzyka dezinformacji
+    const fakeScoreCtx = document.getElementById('fakeScoreChart').getContext('2d');
+    new Chart(fakeScoreCtx, {
+        type: 'bar',
+        data: {
+            labels: ["BBC", "Gazeta Prawna"],
+            datasets: [{
+                label: 'Średnie ryzyko dezinformacji (%)',
+                data: [25.47, 17.156],
+                backgroundColor: ['#e74c3c', '#27ae60'],
+                borderColor: ['#c0392b', '#229954'],
+                borderWidth: 1
+            }]
+        },
+        options: {
+            responsive: true,
+            plugins: {
+                legend: { display: true, position: 'top' }
+            },
+            scales: {
+                y: {
+                    beginAtZero: true,
+                    max: Math.max(25.47, 50),
+                    title: {
+                        display: true,
+                        text: 'Procent ryzyka'
+                    }
+                }
+            }
+        }
+    });
+    
+    // Wykres wydajności
+    const performanceCtx = document.getElementById('performanceChart').getContext('2d');
+    new Chart(performanceCtx, {
+        type: 'line',
+        data: {
+            labels: ["BBC", "Gazeta Prawna"],
+            datasets: [{
+                label: 'Czas analizy (sekundy)',
+                data: [5.216013669967651, 15.029404878616333],
+                backgroundColor: 'rgba(52, 152, 219, 0.2)',
+                borderColor: '#3498db',
+                borderWidth: 2,
+                tension: 0.3,
+                fill: true
+            }]
+        },
+        options: {
+            responsive: true,
+            plugins: {
+                legend: { display: true, position: 'top' }
+            },
+            scales: {
+                y: {
+                    beginAtZero: true,
+                    title: {
+                        display: true,
+                        text: 'Czas (s)'
+                    }
+                }
+            }
+        }
+    });
+    
+    // Funkcja pomocnicza do mapowania sentymentów na kolory
+    function getSentimentColors(labels) {
+        const colorMap = {
+            'Negatywne': '#e74c3c',  // czerwony
+            'Neutralne': '#3498db',   // niebieski
+            'Pozytywne': '#2ecc71',   // zielony
+            'bardzo negatywne': '#c0392b',
+            'bardzo pozytywne': '#27ae60'
+        };
+        
+        return labels.map(label => colorMap[label] || '#95a5a6');
+    }
+    
+    // Wykresy sentymentu
+    const bbcSentimentCtx = document.getElementById('bbcSentimentChart').getContext('2d');
+    new Chart(bbcSentimentCtx, {
+        type: 'doughnut',
+        data: {
+            labels: ["Neutralne", "Pozytywne", "Negatywne"],
+            datasets: [{
+                data: [3, 1, 1],
+                backgroundColor: getSentimentColors(["Neutralne", "Pozytywne", "Negatywne"]),
+                hoverOffset: 10
+            }]
+        },
+        options: {
+            responsive: true,
+            plugins: {
+                legend: { position: 'bottom' }
+            }
+        }
+    });
+    
+    const gazetaSentimentCtx = document.getElementById('gazetaSentimentChart').getContext('2d');
+    new Chart(gazetaSentimentCtx, {
+        type: 'doughnut',
+        data: {
+            labels: ["Neutralne"],
+            datasets: [{
+                data: [5],
+                backgroundColor: getSentimentColors(["Neutralne"]),
+                hoverOffset: 10
+            }]
+        },
+        options: {
+            responsive: true,
+            plugins: {
+                legend: { position: 'bottom' }
+            }
+        }
+    });
+</script>
+</body>
+</html>

TruthScan AI_backend/truthscan_report.txt

@@ -0,0 +1,97 @@
+
+================================================================================
+RAPORT PORÓWNAWCZY TRUTHSCAN AI - BBC vs GAZETA PRAWNA
+================================================================================
+Data wykonania: 2025-12-20 08:56:33
+Backend URL: http://localhost:8000
+Frontend URL: http://localhost:3000
+================================================================================
+
+PODSUMOWANIE TESTOW:
+================================================================================
+Wszystkie testy: 7
+Przepuszczone:   7
+Nieudane:        0
+Ostrzeżenia:     0
+Wskaźnik sukcesu: 100.0%
+
+================================================================================
+WYNIKI PORÓWNANIA:
+================================================================================
+
+BBC:
+  • Artykułów: 5
+  • Średnie fake_probability: 25.47%
+  • Czas odpowiedzi: 5.22s
+  • Rozkład sentymentu: {"Neutralne": 3, "Pozytywne": 1, "Negatywne": 1}
+
+Gazeta Prawna:
+  • Artykułów: 5
+  • Średnie fake_probability: 17.16%
+  • Czas odpowiedzi: 15.03s
+  • Rozkład sentymentu: {"Neutralne": 5}
+
+ANALIZA RÓŻNIC:
+  • Różnica w fake_probability: 8.31%
+  • Różnica w czasie odpowiedzi: 9.81s
+
+================================================================================
+WYNIKI SZCZEGÓŁOWE:
+================================================================================
+✅ API Availability [2.07s]
+   Swagger UI dostępny (200)
+   Czas: 08:55:32
+
+✅ GET /sources [2.06s]
+   Znaleziono 10 źródeł | ✅ BBC dostępne | ✅ Gazeta Prawna dostępne
+   Czas: 08:55:35
+
+✅ GET /news/BBC [5.22s]
+   Pobrano 5 artykułów | Źródło: BBC | Pola: title, sentiment, fake_probability, summary, link, published | Przykład: 'Who and what is in the Epstein files?'
+   Czas: 08:55:40
+
+✅ GET /news/GazetaPrawna [15.03s]
+   Pobrano 5 artykułów | Źródło: GazetaPrawna | Pola: title, sentiment, fake_probability, summary, link, published | Przykład: 'Fałszywe oskarżenia na policji mogą zrujnować życi...'
+   Czas: 08:55:55
+
+✅ Source Comparison 
+   BBC: 5 art, 25.5% fake, 5.2s | Gazeta: 5 art, 17.2% fake, 15.0s
+   Czas: 08:55:55
+
+✅ CRUD Operations - BBC 
+   Zapis: ✅ (2.07s) | Odczyt: ✅ (15 artykułów, 2.09s) | Usuwanie: ✅ (Status: 200)
+   Czas: 08:56:10
+
+✅ CRUD Operations - GazetaPrawna 
+   Zapis: ✅ (2.06s) | Odczyt: ✅ (15 artykułów, 2.11s) | Usuwanie: ✅ (Status: 200)
+   Czas: 08:56:33
+
+
+================================================================================
+PRZYKŁADOWE ARTYKUŁY:
+================================================================================
+BBC:
+  1. Who and what is in the Epstein files?
+  2. David Walliams denies inappropriate behaviour after publisher drops him
+  3. US carries out 'massive' strike against IS in Syria
+
+Gazeta Prawna:
+  1. Fałszywe oskarżenia na policji mogą zrujnować życie – sprawdź, kiedy grozi za ni
+  2. Polacy za granicą: w tym kraju mieszka ich tylko dwoje. Zamiast polskiej zimy ma
+  3. Okrągły Stół porwany przez nurt Historii [FELIETON]
+
+================================================================================
+WNIOSKI I REKOMENDACJE:
+================================================================================
+1. System działa poprawnie
+2. Obsługa języka polskiego: SPRAWNIE
+3. Średni czas odpowiedzi: 6.09s
+4. Główne problemy: 0 błędów
+5. Gotowość do dalszych testów: TAK
+
+REKOMENDACJE:
+1. Wszystko działa poprawnie
+2. Przeprowadzić testy manualne interfejsu
+3. Przetestować więcej źródeł RSS
+4. Sprawdzić działanie na różnych przeglądarkach
+5. Modele działają spójnie dla obu języków

TruthScan AI_backend/truthscan_test.py

@@ -0,0 +1,1135 @@
+"""
+SKRYPT TESTOWY TRUTHSCAN AI - TEST PORÓWNAWCZY BBC I GAZETA PRAWNA
+"""
+
+import requests
+import json
+import time
+import statistics
+import os
+from datetime import datetime
+from collections import defaultdict
+from typing import Dict, List, Any, Optional
+
+class TruthScanComparativeTester:
+    def __init__(self, base_url="http://localhost:8000", frontend_url="http://localhost:3000"):
+        self.base_url = base_url
+        self.frontend_url = frontend_url
+        self.results = []
+        self.errors = []
+        self.performance_data = []
+        self.bbc_results = {}
+        self.gazeta_results = {}
+        self.comparison_data = {}
+        
+    def log_test(self, test_name: str, status: str, details: str = "", duration: float = None):
+        """Zapisuje wynik testu"""
+        result = {
+            "test_name": test_name,
+            "status": status,
+            "timestamp": datetime.now().isoformat(),
+            "details": details,
+            "duration": duration
+        }
+        self.results.append(result)
+        
+        status_symbol = "✅" if status == "PASS" else "❌" if status == "FAIL" else "⚠️"
+        print(f"{status_symbol} {test_name}: {details}")
+        
+        if status == "FAIL":
+            self.errors.append(result)
+    
+##########
+# Test dostępności API
+##########
+
+    def test_api_availability(self):
+        test_name = "API Availability"
+        start = time.time()
+        
+        try:
+            response = requests.get(f"{self.base_url}/docs", timeout=10)
+            duration = time.time() - start
+            
+            if response.status_code == 200:
+                self.log_test(test_name, "PASS", 
+                            f"Swagger UI dostępny ({response.status_code})", duration)
+                return True
+            else:
+                self.log_test(test_name, "FAIL", 
+                            f"Status code: {response.status_code}", duration)
+                return False
+        except Exception as e:
+            self.log_test(test_name, "FAIL", f"Błąd połączenia: {str(e)}", time.time() - start)
+            return False
+    
+############
+# Test: Sprawdzenie dostępnych źródeł
+############
+
+    def test_sources_endpoint(self):
+        
+        test_name = "GET /sources"
+        start = time.time()
+        
+        try:
+            response = requests.get(f"{self.base_url}/sources", timeout=15)
+            duration = time.time() - start
+            
+            if response.status_code == 200:
+                data = response.json()
+                
+                if isinstance(data, list):
+                    details = f"Znaleziono {len(data)} źródeł"
+                    
+                    # Sprawdzenie czy oba źródła są dostępne
+                    sources_lower = [s.lower() for s in data]
+                    bbc_available = "bbc" in sources_lower or any("bbc" in s.lower() for s in data)
+                    gazeta_available = "gazetaprawna" in sources_lower or any("gazeta" in s.lower() for s in data)
+                    
+                    if not bbc_available:
+                        details += " | ❌ BBC niedostępne"
+                        status = "WARNING"
+                    elif not gazeta_available:
+                        details += " | ❌ Gazeta Prawna niedostępne"
+                        status = "WARNING"
+                    else:
+                        details += " | ✅ BBC dostępne | ✅ Gazeta Prawna dostępne"
+                        status = "PASS"
+                    
+                    self.log_test(test_name, status, details, duration)
+                    return data
+                else:
+                    self.log_test(test_name, "FAIL", f"Nieoczekiwany typ danych: {type(data)}", duration)
+                    return None
+            else:
+                self.log_test(test_name, "FAIL", 
+                            f"Status code: {response.status_code}", duration)
+                return None
+        except Exception as e:
+            self.log_test(test_name, "FAIL", f"Błąd: {str(e)}", time.time() - start)
+            return None
+    
+    def test_single_source_detailed(self, source: str, source_name: str):
+        print(f"\n{'='*60}")
+        print(f"🔍 SZCZEGÓŁOWY TEST: {source_name} ({source})")
+        print(f"{'='*60}")
+        
+        test_results = {
+            "source": source,
+            "source_name": source_name,
+            "articles": [],
+            "sentiment_distribution": defaultdict(int),
+            "fake_scores": [],
+            "performance": 0,
+            "errors": [],
+            "sample_titles": []
+        }
+        
+#### Test 1: Pobieranie artykułów
+        test_name = f"GET /news/{source}"
+        start = time.time()
+        
+        try:
+            response = requests.get(f"{self.base_url}/news/{source}", timeout=30)
+            duration = time.time() - start
+            test_results["performance"] = duration
+            
+            if response.status_code != 200:
+                self.log_test(test_name, "FAIL", 
+                            f"Status code: {response.status_code}", duration)
+                test_results["errors"].append(f"HTTP {response.status_code}")
+                return test_results
+            
+            data = response.json()
+            
+            if not data:
+                self.log_test(test_name, "FAIL", "Brak danych w odpowiedzi", duration)
+                return test_results
+            
+            if isinstance(data, dict) and "articles" in data:
+                articles = data["articles"]
+                source_from_response = data.get("source", source)
+                test_results["articles"] = articles
+                
+                details = f"Pobrano {len(articles)} artykułów | Źródło: {source_from_response}"
+                
+                if len(articles) > 0:
+                    
+                    first_article = articles[0]
+                    available_fields = [field for field in ["title", "sentiment", "fake_probability", "summary", "link", "published"] 
+                                      if field in first_article]
+                    
+                    details += f" | Pola: {', '.join(available_fields)}"
+                    
+                    title = first_article.get("title", "Brak tytułu")
+                    if len(title) > 50:
+                        title = title[:50] + "..."
+                    details += f" | Przykład: '{title}'"
+                    
+                    for i, article in enumerate(articles[:3]):
+                        title = article.get("title", "")
+                        if title:
+                            test_results["sample_titles"].append(title[:80])
+                
+                self.log_test(test_name, "PASS", details, duration)
+                
+                # Zapis danych wydajności
+                self.performance_data.append({
+                    "endpoint": test_name,
+                    "duration": duration,
+                    "source": source
+                })
+                
+            else:
+                self.log_test(test_name, "WARNING", 
+                            f"Nieoczekiwany format danych: {type(data)}", duration)
+                return test_results
+        
+        except Exception as e:
+            self.log_test(test_name, "FAIL", f"Błąd: {str(e)}", time.time() - start)
+            test_results["errors"].append(str(e))
+            return test_results
+        
+#### Test 2: Szczegółowa analiza NLP dla każdego artykułu
+        if test_results["articles"]:
+            print(f"\n📊 ANALIZA NLP DLA {source_name}:")
+            
+            for i, article in enumerate(test_results["articles"][:5]):  
+                print(f"\n  📄 Artykuł {i+1}:")
+                
+                title = article.get("title", "Brak tytułu")
+                if len(title) > 60:
+                    title_display = title[:60] + "..."
+                else:
+                    title_display = title
+                print(f"     Tytuł: {title_display}")
+                
+#### Sentyment
+                sentiment = article.get("sentiment", "Nieznany")
+                sentiment_score = article.get("sentiment_score", 0)
+                print(f"     Sentyment: {sentiment} ({sentiment_score:.2f})")
+                
+#### Fake probability
+                fake_prob = article.get("fake_probability", 0)
+                if isinstance(fake_prob, (int, float)):
+                    print(f"     Fake probability: {fake_prob}%")
+                    
+#### Kategoryzacja ryzyka
+                    if fake_prob < 15:
+                        risk = "NISKIE"
+                    elif fake_prob < 30:
+                        risk = "ŚREDNIE"
+                    else:
+                        risk = "WYSOKIE"
+                    print(f"     Ryzyko dezinformacji: {risk}")
+                    
+                    test_results["fake_scores"].append(fake_prob)
+                
+                test_results["sentiment_distribution"][sentiment] += 1
+                
+#### Link i data
+                link = article.get("link", "")
+                if link:
+                    domain = link.split('/')[2] if len(link.split('/')) > 2 else link
+                    print(f"     Źródło: {domain}")
+                
+                published = article.get("published", "Brak daty")
+                print(f"     Data publikacji: {published}")
+        
+#### Test 3: Analiza statystyczna
+        if test_results["fake_scores"]:
+            avg_fake = statistics.mean(test_results["fake_scores"])
+            min_fake = min(test_results["fake_scores"])
+            max_fake = max(test_results["fake_scores"])
+            
+            print(f"\n  📈 STATYSTYKI {source_name}:")
+            print(f"     Średnie fake_probability: {avg_fake:.2f}%")
+            print(f"     Zakres: {min_fake:.2f}% - {max_fake:.2f}%")
+            print(f"     Czas odpowiedzi: {test_results['performance']:.2f}s")
+            
+            # Analiza rozkładu sentymentu
+            if test_results["sentiment_distribution"]:
+                print(f"     Rozkład sentymentu:")
+                for sentiment, count in test_results["sentiment_distribution"].items():
+                    percentage = (count / len(test_results["articles"])) * 100
+                    print(f"       {sentiment}: {count} ({percentage:.1f}%)")
+        
+        return test_results
+    
+###########
+# Porównanie wyników BBC i Gazety Prawnej
+###########
+    def compare_sources(self, bbc_data: Dict, gazeta_data: Dict):
+        
+        print(f"\n{'='*60}")
+        print(f"🔄 PORÓWNANIE BBC vs GAZETA PRAWNA")
+        print(f"{'='*60}")
+        
+        # Obliczanie średnich - z obsługą pustych list
+        bbc_fake_scores = bbc_data.get("fake_scores", [])
+        gazeta_fake_scores = gazeta_data.get("fake_scores", [])
+        
+        bbc_avg_fake = statistics.mean(bbc_fake_scores) if bbc_fake_scores else 0
+        gazeta_avg_fake = statistics.mean(gazeta_fake_scores) if gazeta_fake_scores else 0
+        
+        comparison = {
+            "source_count": {
+                "BBC": len(bbc_data.get("articles", [])),
+                "Gazeta Prawna": len(gazeta_data.get("articles", []))
+            },
+            "avg_fake_score": {
+                "BBC": bbc_avg_fake,
+                "Gazeta Prawna": gazeta_avg_fake
+            },
+            "sentiment_distribution": {
+                "BBC": dict(bbc_data.get("sentiment_distribution", {})),
+                "Gazeta Prawna": dict(gazeta_data.get("sentiment_distribution", {}))
+            },
+            "performance": {
+                "BBC": bbc_data.get("performance", 0),
+                "Gazeta Prawna": gazeta_data.get("performance", 0)
+            },
+            "sample_titles": {
+                "BBC": bbc_data.get("sample_titles", []),
+                "Gazeta Prawna": gazeta_data.get("sample_titles", [])
+            }
+        }
+        
+#### Wyświetlanie wyników porównania
+        print(f"\n📊 LICZBA ARTYKUŁÓW:")
+        print(f"   BBC: {comparison['source_count']['BBC']}")
+        print(f"   Gazeta Prawna: {comparison['source_count']['Gazeta Prawna']}")
+        
+        print(f"\n📊 ŚREDNIE RYZYKO DEZINFORMACJI:")
+        print(f"   BBC: {comparison['avg_fake_score']['BBC']:.2f}%")
+        print(f"   Gazeta Prawna: {comparison['avg_fake_score']['Gazeta Prawna']:.2f}%")
+        
+#### Analiza różnic
+        if comparison['avg_fake_score']['BBC'] > 0 and comparison['avg_fake_score']['Gazeta Prawna'] > 0:
+            fake_diff = abs(comparison['avg_fake_score']['BBC'] - comparison['avg_fake_score']['Gazeta Prawna'])
+            print(f"   Różnica: {fake_diff:.2f}%")
+            
+            if fake_diff > 10:
+                print(f"   ⚠️ Znacząca różnica w ryzyku dezinformacji")
+        
+        print(f"\n📊 ROZKŁAD SENTYMENTU:")
+        
+        for source in ["BBC", "Gazeta Prawna"]:
+            print(f"\n   {source}:")
+            dist = comparison['sentiment_distribution'][source]
+            total = sum(dist.values()) if dist else 1
+            
+            if dist:
+                for sentiment, count in dist.items():
+                    percentage = (count / total) * 100 if total > 0 else 0
+                    print(f"     {sentiment}: {count} ({percentage:.1f}%)")
+            else:
+                print("     Brak danych o sentymencie")
+        
+        print(f"\n📊 WYDANOŚĆ:")
+        print(f"   BBC: {comparison['performance']['BBC']:.2f}s")
+        print(f"   Gazeta Prawna: {comparison['performance']['Gazeta Prawna']:.2f}s")
+        
+        if comparison['performance']['BBC'] > 0 and comparison['performance']['Gazeta Prawna'] > 0:
+            perf_diff = comparison['performance']['Gazeta Prawna'] - comparison['performance']['BBC']
+            if perf_diff > 1:
+                print(f"   ⏱️ Gazeta Prawna wolniejsza o {perf_diff:.2f}s (język polski)")
+            elif perf_diff < -1:
+                print(f"   ⏱️ BBC wolniejsze o {abs(perf_diff):.2f}s")
+            else:
+                print(f"   ⚡ Porównywalna wydajność")
+        
+#### Logowanie testu porównawczego
+        details = (f"BBC: {comparison['source_count']['BBC']} art, "
+                  f"{comparison['avg_fake_score']['BBC']:.1f}% fake, "
+                  f"{comparison['performance']['BBC']:.1f}s | "
+                  f"Gazeta: {comparison['source_count']['Gazeta Prawna']} art, "
+                  f"{comparison['avg_fake_score']['Gazeta Prawna']:.1f}% fake, "
+                  f"{comparison['performance']['Gazeta Prawna']:.1f}s")
+        
+        self.log_test("Source Comparison", "PASS", details)
+        
+        self.comparison_data = comparison
+        return comparison
+    
+################
+#Test operacji CRUD z artykułami z danego źródła
+##############
+
+    def test_crud_operations_for_source(self, source: str):
+        
+        test_name = f"CRUD Operations - {source}"
+        
+##### Najpierw pobierz artykuły ze źródła
+
+        try:
+            response = requests.get(f"{self.base_url}/news/{source}", timeout=20)
+            if response.status_code != 200:
+                self.log_test(test_name, "FAIL", f"Nie można pobrać artykułów: {response.status_code}")
+                return None
+            
+            data = response.json()
+            articles = data.get("articles", []) if isinstance(data, dict) else data
+            
+            if not articles:
+                self.log_test(test_name, "WARNING", "Brak artykułów do testu CRUD")
+                return None
+            
+##### Użyj pierwszego artykułu do testu
+            test_article = articles[0]
+            
+#### Dostosuj artykuł do formatu zapisu#############
+            article_to_save = {
+                "title": f"[TEST {source}] {test_article.get('title', 'Testowy artykuł')}",
+                "link": test_article.get("link", "https://example.com/test"),
+                "summary": test_article.get("summary", "Testowy artykuł do weryfikacji systemu."),
+                "published": datetime.now().isoformat(),
+                "sentiment": test_article.get("sentiment", "Neutral"),
+                "fake_probability": test_article.get("fake_probability", 15.5),
+                "source": source
+            }
+            
+            operations = []
+            
+#### 1. Zapis artykułu#############################
+            try:
+                start = time.time()
+                response = requests.post(
+                    f"{self.base_url}/save-article",
+                    json=article_to_save,
+                    timeout=10
+                )
+                save_time = time.time() - start
+                
+                if response.status_code in [200, 201]:
+                    operations.append(("Zapis", "✅", f"{save_time:.2f}s"))
+                else:
+                    operations.append(("Zapis", "❌", f"Status: {response.status_code}"))
+            except Exception as e:
+                operations.append(("Zapis", "❌", f"Błąd: {str(e)[:30]}"))
+            
+#### 2. Odczyt zapisanych artykułów############
+            try:
+                start = time.time()
+                response = requests.get(f"{self.base_url}/saved-articles", timeout=10)
+                fetch_time = time.time() - start
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if isinstance(data, list):
+                        found = any(isinstance(a, dict) and source in a.get("title", "") for a in data)
+                        operations.append(("Odczyt", "✅" if found else "⚠️", 
+                                         f"{len(data)} artykułów, {fetch_time:.2f}s"))
+                    else:
+                        operations.append(("Odczyt", "❌", f"Niewłaściwy format: {type(data)}"))
+                else:
+                    operations.append(("Odczyt", "❌", f"Status: {response.status_code}"))
+            except Exception as e:
+                operations.append(("Odczyt", "❌", f"Błąd: {str(e)[:30]}"))
+            
+
+#### 3. Usuwanie testowego artykułu##############
+
+            try:
+                response = requests.delete(
+                    f"{self.base_url}/delete-article",
+                    json={"title": article_to_save["title"]},
+                    timeout=5
+                )
+                operations.append(("Usuwanie", "✅" if response.status_code == 200 else "⚠️", 
+                                 f"Status: {response.status_code}"))
+            except Exception as e:
+                operations.append(("Usuwanie", "SKIP", f"Błąd: {str(e)[:30]}"))
+            
+            details = " | ".join([f"{op[0]}: {op[1]} ({op[2]})" for op in operations])
+            success_ops = sum(1 for op in operations if op[1] in ["✅", "SKIP"])
+            status = "PASS" if success_ops >= 2 else "FAIL"
+            
+            self.log_test(test_name, status, details)
+            return operations
+            
+        except Exception as e:
+            self.log_test(test_name, "FAIL", f"Błąd ogólny: {str(e)}")
+            return None
+    
+##################### Generuje raport tekstowy z porównaniem ##########
+
+    def generate_text_report(self, filename: str = "truthscan_report.txt"):
+        
+        total_tests = len(self.results)
+        passed = sum(1 for r in self.results if r["status"] == "PASS")
+        
+        report = f"""
+{'='*80}
+RAPORT PORÓWNAWCZY TRUTHSCAN AI - BBC vs GAZETA PRAWNA
+{'='*80}
+Data wykonania: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+Backend URL: {self.base_url}
+Frontend URL: {self.frontend_url}
+{'='*80}
+
+PODSUMOWANIE TESTOW:
+{'='*80}
+Wszystkie testy: {total_tests}
+Przepuszczone:   {passed}
+Nieudane:        {sum(1 for r in self.results if r["status"] == "FAIL")}
+Ostrzeżenia:     {sum(1 for r in self.results if r["status"] == "WARNING")}
+Wskaźnik sukcesu: {passed/total_tests*100:.1f}%
+
+{'='*80}
+WYNIKI PORÓWNANIA:
+{'='*80}
+"""
+        
+        if self.comparison_data:
+            report += f"""
+BBC:
+  • Artykułów: {self.comparison_data['source_count']['BBC']}
+  • Średnie fake_probability: {self.comparison_data['avg_fake_score']['BBC']:.2f}%
+  • Czas odpowiedzi: {self.comparison_data['performance']['BBC']:.2f}s
+  • Rozkład sentymentu: {json.dumps(self.comparison_data['sentiment_distribution']['BBC'], ensure_ascii=False)}
+
+Gazeta Prawna:
+  • Artykułów: {self.comparison_data['source_count']['Gazeta Prawna']}
+  • Średnie fake_probability: {self.comparison_data['avg_fake_score']['Gazeta Prawna']:.2f}%
+  • Czas odpowiedzi: {self.comparison_data['performance']['Gazeta Prawna']:.2f}s
+  • Rozkład sentymentu: {json.dumps(self.comparison_data['sentiment_distribution']['Gazeta Prawna'], ensure_ascii=False)}
+
+ANALIZA RÓŻNIC:
+  • Różnica w fake_probability: {abs(self.comparison_data['avg_fake_score']['BBC'] - self.comparison_data['avg_fake_score']['Gazeta Prawna']):.2f}%
+  • Różnica w czasie odpowiedzi: {abs(self.comparison_data['performance']['BBC'] - self.comparison_data['performance']['Gazeta Prawna']):.2f}s
+"""
+        
+        report += f"""
+{'='*80}
+WYNIKI SZCZEGÓŁOWE:
+{'='*80}
+"""
+        
+        for result in self.results:
+            status_icon = "✅" if result["status"] == "PASS" else "❌" if result["status"] == "FAIL" else "⚠️"
+            duration = f"[{result['duration']:.2f}s]" if result["duration"] else ""
+            report += f"{status_icon} {result['test_name']} {duration}\n"
+            report += f"   {result['details']}\n"
+            report += f"   Czas: {result['timestamp'][11:19]}\n\n"
+        
+        # Przykładowe artykuły
+        if self.bbc_results.get("sample_titles") or self.gazeta_results.get("sample_titles"):
+            report += f"""
+{'='*80}
+PRZYKŁADOWE ARTYKUŁY:
+{'='*80}
+"""
+            
+            if self.bbc_results.get("sample_titles"):
+                report += "BBC:\n"
+                for i, title in enumerate(self.bbc_results["sample_titles"][:3]):
+                    report += f"  {i+1}. {title}\n"
+            
+            if self.gazeta_results.get("sample_titles"):
+                report += "\nGazeta Prawna:\n"
+                for i, title in enumerate(self.gazeta_results["sample_titles"][:3]):
+                    report += f"  {i+1}. {title}\n"
+        
+        report += f"""
+{'='*80}
+WNIOSKI I REKOMENDACJE:
+{'='*80}
+1. System {'działa poprawnie' if passed > total_tests/2 else 'wymaga poprawy'}
+2. Obsługa języka polskiego: {'SPRAWNIE' if self.gazeta_results.get('articles') else 'PROBLEMY'}
+3. Średni czas odpowiedzi: {statistics.mean([r['duration'] for r in self.results if r.get('duration')]):.2f}s
+4. Główne problemy: {len(self.errors)} błędów
+5. Gotowość do dalszych testów: {'TAK' if len(self.errors) < 3 else 'NIE'}
+
+REKOMENDACJE:
+1. {'Naprawić wykryte błędy' if self.errors else 'Wszystko działa poprawnie'}
+2. Przeprowadzić testy manualne interfejsu
+3. Przetestować więcej źródeł RSS
+4. Sprawdzić działanie na różnych przeglądarkach
+5. {'Wymagany fine-tuning modeli dla języka polskiego' 
+    if self.comparison_data and abs(self.comparison_data['avg_fake_score']['BBC'] - self.comparison_data['avg_fake_score']['Gazeta Prawna']) > 15 
+    else 'Modele działają spójnie dla obu języków'}
+"""
+        
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(report)
+        
+        print(f"📝 Raport tekstowy zapisany jako: {filename}")
+        
+        return report
+    
+        """Generuje szczegółowy raport HTML z porównaniem źródeł"""
+
+    def generate_comparative_html_report(self, filename: str = "truthscan_report.html"):
+        
+        total_tests = len(self.results)
+        passed = sum(1 for r in self.results if r["status"] == "PASS")
+        
+        # Przygotowanie danych do wykresów
+        if self.comparison_data:
+            sources = ["BBC", "Gazeta Prawna"]
+            fake_scores = [
+                self.comparison_data['avg_fake_score']['BBC'], 
+                self.comparison_data['avg_fake_score']['Gazeta Prawna']
+            ]
+            performance_times = [
+                self.comparison_data['performance']['BBC'], 
+                self.comparison_data['performance']['Gazeta Prawna']
+            ]
+            
+            # Dane sentymentu
+            bbc_sentiments = self.comparison_data['sentiment_distribution']['BBC']
+            gazeta_sentiments = self.comparison_data['sentiment_distribution']['Gazeta Prawna']
+            
+            # Przygotowanie etykiet i wartości dla wykresów sentymentu
+            bbc_sentiment_labels = list(bbc_sentiments.keys()) if bbc_sentiments else ['Neutralny', 'Pozytywny', 'Negatywny']
+            bbc_sentiment_values = list(bbc_sentiments.values()) if bbc_sentiments else [1, 1, 1]
+            
+            gazeta_sentiment_labels = list(gazeta_sentiments.keys()) if gazeta_sentiments else ['Neutralny', 'Pozytywny', 'Negatywny']
+            gazeta_sentiment_values = list(gazeta_sentiments.values()) if gazeta_sentiments else [1, 1, 1]
+        else:
+            sources = ["BBC", "Gazeta Prawna"]
+            fake_scores = [0, 0]
+            performance_times = [0, 0]
+            bbc_sentiment_labels = ['Neutralny', 'Pozytywny', 'Negatywny']
+            bbc_sentiment_values = [1, 1, 1]
+            gazeta_sentiment_labels = ['Neutralny', 'Pozytywny', 'Negatywny']
+            gazeta_sentiment_values = [1, 1, 1]
+        
+        html = f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Raport porównawczy TruthScan AI - BBC vs Gazeta Prawna</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        body {{ 
+            font-family: 'Segoe UI', Arial, sans-serif; 
+            margin: 0; 
+            padding: 20px; 
+            background: #f0f2f5;
+        }}
+        .container {{ 
+            max-width: 1200px; 
+            margin: 0 auto; 
+            background: white; 
+            padding: 30px; 
+            border-radius: 10px; 
+            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+        }}
+        h1 {{ 
+            color: #2c3e50; 
+            text-align: center; 
+            margin-bottom: 20px; 
+            border-bottom: 3px solid #3498db;
+            padding-bottom: 10px;
+        }}
+        .header {{ 
+            text-align: center; 
+            margin-bottom: 30px; 
+        }}
+        .test-date {{ 
+            color: #7f8c8d; 
+            font-size: 1em; 
+            margin-top: 5px;
+        }}
+        
+        .comparison-section {{ 
+            display: grid; 
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); 
+            gap: 20px; 
+            margin-bottom: 30px;
+        }}
+        .comparison-card {{ 
+            background: #fff; 
+            padding: 20px; 
+            border-radius: 8px; 
+            box-shadow: 0 2px 10px rgba(0,0,0,0.08);
+            border-left: 4px solid #3498db;
+        }}
+        .comparison-card h3 {{ 
+            color: #2c3e50; 
+            margin-top: 0;
+        }}
+        
+        .chart-container {{ 
+            position: relative; 
+            height: 250px; 
+            margin: 15px 0;
+        }}
+        
+        .stats-grid {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin: 20px 0;
+        }}
+        .stat-box {{ 
+            padding: 15px;
+            border-radius: 6px;
+            color: white;
+            text-align: center;
+        }}
+        .bbc-stat {{ 
+            background: linear-gradient(135deg, #e74c3c, #c0392b);
+        }}
+        .gazeta-stat {{ 
+            background: linear-gradient(135deg, #27ae60, #229954);
+        }}
+        
+        .source-details {{ 
+            background: #ecf0f1; 
+            padding: 15px; 
+            border-radius: 6px; 
+            margin: 20px 0;
+        }}
+        
+        .results-table {{ 
+            width: 100%; 
+            border-collapse: collapse; 
+            margin-top: 20px;
+        }}
+        .results-table th, .results-table td {{ 
+            padding: 12px; 
+            text-align: left; 
+            border-bottom: 1px solid #ddd;
+        }}
+        .results-table th {{ 
+            background-color: #3498db; 
+            color: white;
+        }}
+        .results-table tr:hover {{ 
+            background-color: #f5f5f5;
+        }}
+        
+        .pass {{ color: #27ae60; font-weight: bold; }}
+        .fail {{ color: #e74c3c; font-weight: bold; }}
+        .warn {{ color: #f39c12; font-weight: bold; }}
+        
+        .insights {{ 
+            background: #2c3e50; 
+            color: white; 
+            padding: 20px; 
+            border-radius: 8px; 
+            margin-top: 30px;
+        }}
+        
+        .footer {{ 
+            text-align: center; 
+            margin-top: 30px; 
+            color: #7f8c8d; 
+            font-size: 0.9em;
+            border-top: 1px solid #ecf0f1;
+            padding-top: 15px;
+        }}
+        
+        .highlight {{ 
+            background: #fff3cd;
+            padding: 10px;
+            border-radius: 5px;
+            border-left: 4px solid #ffc107;
+            margin: 15px 0;
+        }}
+        .conclusions {{ 
+            background: #2c3e50; 
+            color: white; 
+            padding: 20px; 
+            border-radius: 8px; 
+            margin-top: 30px;
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>📊 RAPORT PORÓWNAWCZY TRUTHSCAN AI</h1>
+            <h2>BBC vs Gazeta Prawna - Analiza systemu detekcji dezinformacji</h2>
+            <div class="test-date">Data testów: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</div>
+        </div>
+        
+        <div class="stats-grid">
+            <div class="stat-box bbc-stat">
+                <h3>BBC</h3>
+                <p>Artykułów: {self.comparison_data.get('source_count', {}).get('BBC', 0)}</p>
+                <p>Fake: {fake_scores[0]:.1f}%</p>
+                <p>Czas: {performance_times[0]:.2f}s</p>
+            </div>
+            <div class="stat-box gazeta-stat">
+                <h3>Gazeta Prawna</h3>
+                <p>Artykułów: {self.comparison_data.get('source_count', {}).get('Gazeta Prawna', 0)}</p>
+                <p>Fake: {fake_scores[1]:.1f}%</p>
+                <p>Czas: {performance_times[1]:.2f}s</p>
+            </div>
+        </div>
+        
+        <div class="comparison-section">
+            <div class="comparison-card">
+                <h3>📈 Średnie ryzyko dezinformacji</h3>
+                <div class="chart-container">
+                    <canvas id="fakeScoreChart"></canvas>
+                </div>
+            </div>
+            
+            <div class="comparison-card">
+                <h3>⚡ Wydajność systemu</h3>
+                <div class="chart-container">
+                    <canvas id="performanceChart"></canvas>
+                </div>
+            </div>
+        </div>
+        
+        <div class="comparison-section">
+            <div class="comparison-card">
+                <h3>🎭 Rozkład sentymentu - BBC</h3>
+                <div class="chart-container">
+                    <canvas id="bbcSentimentChart"></canvas>
+                </div>
+            </div>
+            
+            <div class="comparison-card">
+                <h3>🎭 Rozkład sentymentu - Gazeta Prawna</h3>
+                <div class="chart-container">
+                    <canvas id="gazetaSentimentChart"></canvas>
+                </div>
+            </div>
+        </div>
+        
+        <div class="highlight">
+            <h4>🔍 Kluczowe różnice:</h4>
+            <p>• Różnica w ryzyku dezinformacji: <strong>{abs(fake_scores[0] - fake_scores[1]):.1f}%</strong></p>
+            <p>• Różnica w czasie analizy: <strong>{abs(performance_times[0] - performance_times[1]):.2f}s</strong></p>
+            {"<p style='color: #e74c3c;'>• ⚠️ Znacząca różnica w wykrywaniu dezinformacji między językami</p>" 
+             if abs(fake_scores[0] - fake_scores[1]) > 10 else 
+             "<p style='color: #27ae60;'>• ✅ Spójna skuteczność detekcji między językami</p>"}
+        </div>
+        
+        <div class="source-details">
+            <h4>📰 Przykładowe artykuły z analizą</h4>
+            
+            <h5>BBC:</h5>"""
+        
+#### Przykładowe artykuły BBC
+        if self.bbc_results.get("sample_titles"):
+            for i, title in enumerate(self.bbc_results["sample_titles"][:2]):
+                html += f"<p><strong>{i+1}.</strong> {title}...</p>"
+        else:
+            html += "<p>Brak przykładowych artykułów</p>"
+        
+        html += """
+            <h5>Gazeta Prawna:</h5>"""
+        
+#### Przykładowe artykuły Gazeta Prawna
+        if self.gazeta_results.get("sample_titles"):
+            for i, title in enumerate(self.gazeta_results["sample_titles"][:2]):
+                html += f"<p><strong>{i+1}.</strong> {title}...</p>"
+        else:
+            html += "<p>Brak przykładowych artykułów</p>"
+        
+        html += f"""
+        </div>
+        
+        <h3>📋 Wyniki testów ({passed}/{total_tests} przepuszczonych)</h3>
+        <table class="results-table">
+            <thead>
+                <tr>
+                    <th>Test</th>
+                    <th>Status</th>
+                    <th>Szczegóły</th>
+                    <th>Czas [s]</th>
+                </tr>
+            </thead>
+            <tbody>"""
+        
+        for result in self.results:
+            status_class = "pass" if result["status"] == "PASS" else "fail" if result["status"] == "FAIL" else "warn"
+            status_display = {"PASS": "✅", "FAIL": "❌", "WARNING": "⚠️"}.get(result["status"], "?")
+            duration = f"{result['duration']:.2f}" if result["duration"] else "-"
+            
+            html += f"""
+                <tr>
+                    <td>{result['test_name']}</td>
+                    <td class="{status_class}">{status_display} {result['status']}</td>
+                    <td>{result['details']}</td>
+                    <td>{duration}</td>
+                </tr>"""
+        
+        html += f"""
+            </tbody>
+        </table>
+        
+        <div class="conclusions">
+            <h4>Wnioski i rekomendacje</h4>
+            
+            <h5>Kluczowe wnioski:</h5>
+            <ul>
+                <li>System skutecznie analizuje źródła anglojęzyczne i polskojęzyczne</li>
+                <li>Analiza treści polskich zajmuje więcej czasu: różnica 12.91s</li>
+                <li>Różnica w wykrywaniu dezinformacji między źródłami: 0.1%</li>
+                <li>Spójna skuteczność detekcji między językami</li>
+            </ul>
+            
+            <h5>Rekomendacje:</h5>
+            <ol>
+                <li>Fine-tuning modeli NLP na polskich danych fact-checkingowych</li>
+                <li>Optymalizacja parsowania polskich znaków diakrytycznych</li>
+                <li>Implementacja cache'owania wyników dla często analizowanych źródeł</li>
+                <li>Rozszerzenie testów o więcej polskich źródeł informacji</li>
+                <li>Przeprowadzenie testów z rzeczywistymi użytkownikami</li>
+            </ol>
+        </div>
+    </div>
+    
+    <div class="footer">
+        <p>Raport wygenerowany automatycznie przez TruthScan AI Comparative Tester</p>
+        <p>System TruthScan AI - Prototyp do walki z dezinformacją</p>
+        <p>Wskaźnik sukcesu testów: {passed/total_tests*100:.1f}% | Błędy: {len(self.errors)}</p>
+    </div>
+</div>
+
+<script>
+    // Wykres ryzyka dezinformacji
+    const fakeScoreCtx = document.getElementById('fakeScoreChart').getContext('2d');
+    new Chart(fakeScoreCtx, {{
+        type: 'bar',
+        data: {{
+            labels: {json.dumps(sources)},
+            datasets: [{{
+                label: 'Średnie ryzyko dezinformacji (%)',
+                data: {json.dumps(fake_scores)},
+                backgroundColor: ['#e74c3c', '#27ae60'],
+                borderColor: ['#c0392b', '#229954'],
+                borderWidth: 1
+            }}]
+        }},
+        options: {{
+            responsive: true,
+            plugins: {{
+                legend: {{ display: true, position: 'top' }}
+            }},
+            scales: {{
+                y: {{
+                    beginAtZero: true,
+                    max: Math.max({max(fake_scores) if fake_scores else 50}, 50),
+                    title: {{
+                        display: true,
+                        text: 'Procent ryzyka'
+                    }}
+                }}
+            }}
+        }}
+    }});
+    
+    // Wykres wydajności
+    const performanceCtx = document.getElementById('performanceChart').getContext('2d');
+    new Chart(performanceCtx, {{
+        type: 'line',
+        data: {{
+            labels: {json.dumps(sources)},
+            datasets: [{{
+                label: 'Czas analizy (sekundy)',
+                data: {json.dumps(performance_times)},
+                backgroundColor: 'rgba(52, 152, 219, 0.2)',
+                borderColor: '#3498db',
+                borderWidth: 2,
+                tension: 0.3,
+                fill: true
+            }}]
+        }},
+        options: {{
+            responsive: true,
+            plugins: {{
+                legend: {{ display: true, position: 'top' }}
+            }},
+            scales: {{
+                y: {{
+                    beginAtZero: true,
+                    title: {{
+                        display: true,
+                        text: 'Czas (s)'
+                    }}
+                }}
+            }}
+        }}
+    }});
+    
+    // Funkcja pomocnicza do mapowania sentymentów na kolory
+    function getSentimentColors(labels) {{
+        const colorMap = {{
+            'Negatywne': '#e74c3c',  // czerwony
+            'Neutralne': '#3498db',   // niebieski
+            'Pozytywne': '#2ecc71',   // zielony
+            'bardzo negatywne': '#c0392b',
+            'bardzo pozytywne': '#27ae60'
+        }};
+        
+        return labels.map(label => colorMap[label] || '#95a5a6');
+    }}
+    
+    // Wykresy sentymentu
+    const bbcSentimentCtx = document.getElementById('bbcSentimentChart').getContext('2d');
+    new Chart(bbcSentimentCtx, {{
+        type: 'doughnut',
+        data: {{
+            labels: {json.dumps(bbc_sentiment_labels)},
+            datasets: [{{
+                data: {json.dumps(bbc_sentiment_values)},
+                backgroundColor: getSentimentColors({json.dumps(bbc_sentiment_labels)}),
+                hoverOffset: 10
+            }}]
+        }},
+        options: {{
+            responsive: true,
+            plugins: {{
+                legend: {{ position: 'bottom' }}
+            }}
+        }}
+    }});
+    
+    const gazetaSentimentCtx = document.getElementById('gazetaSentimentChart').getContext('2d');
+    new Chart(gazetaSentimentCtx, {{
+        type: 'doughnut',
+        data: {{
+            labels: {json.dumps(gazeta_sentiment_labels)},
+            datasets: [{{
+                data: {json.dumps(gazeta_sentiment_values)},
+                backgroundColor: getSentimentColors({json.dumps(gazeta_sentiment_labels)}),
+                hoverOffset: 10
+            }}]
+        }},
+        options: {{
+            responsive: true,
+            plugins: {{
+                legend: {{ position: 'bottom' }}
+            }}
+        }}
+    }});
+</script>
+</body>
+</html>"""
+        
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(html)
+        
+        print(f"\n📄 Raport porównawczy HTML zapisany jako: {filename}")
+        print(f"   Otwórz w przeglądarce: file://{os.path.abspath(filename)}")
+        
+        return filename
+    
+    def run_comparative_tests(self):
+        """Uruchamia pełne testy porównawcze"""
+        print("=" * 70)
+        print("🎯 TRUTHSCAN AI - TESTY PORÓWNAWCZE BBC vs GAZETA PRAWNA")
+        print("=" * 70)
+        print("Ten skrypt przeprowadzi szczegółowe testy obu źródeł")
+        print("i porówna ich wyniki analizy NLP.")
+        print("=" * 70)
+        
+        # Sprawdzenie dostępności API
+        print("\n1️⃣ Sprawdzanie dostępności systemu...")
+        if not self.test_api_availability():
+            print("❌ API niedostępne! Sprawdź czy backend działa.")
+            return False
+        
+        # Test źródeł
+        print("\n2️⃣ Weryfikacja dostępnych źródeł...")
+        sources = self.test_sources_endpoint()
+        
+        if not sources:
+            print("⚠️ Nie udało się pobrać źródeł, używam domyślnych...")
+            sources = ["BBC", "GazetaPrawna"]
+        else:
+            print(f"✅ Znaleziono {len(sources)} źródeł")
+        
+        # Test BBC
+        print("\n3️⃣ Testowanie źródła BBC...")
+        self.bbc_results = self.test_single_source_detailed("BBC", "BBC News")
+        
+        # Test Gazety Prawnej
+        print("\n4️⃣ Testowanie źródła Gazeta Prawna...")
+        self.gazeta_results = self.test_single_source_detailed("GazetaPrawna", "Gazeta Prawna")
+        
+        # Porównanie wyników
+        if self.bbc_results.get("articles") and self.gazeta_results.get("articles"):
+            print("\n5️⃣ Porównywanie wyników BBC i Gazety Prawnej...")
+            self.compare_sources(self.bbc_results, self.gazeta_results)
+        else:
+            print("⚠️ Brak danych do porównania")
+        
+        # Testy CRUD dla obu źródeł
+        print("\n6️⃣ Testy operacji na danych...")
+        self.test_crud_operations_for_source("BBC")
+        self.test_crud_operations_for_source("GazetaPrawna")
+        
+        # Generowanie raportów
+        print("\n" + "=" * 70)
+        print("📊 GENEROWANIE RAPORTÓW")
+        print("=" * 70)
+        
+        html_report = self.generate_comparative_html_report()
+        text_report = self.generate_text_report()
+        
+        # Podsumowanie
+        passed = sum(1 for r in self.results if r["status"] == "PASS")
+        total = len(self.results)
+        
+        print(f"\n{'='*70}")
+        print(f"📋 PODSUMOWANIE TESTOW:")
+        print(f"   Przepuszczono: {passed}/{total} ({passed/total*100:.1f}%)")
+        
+        if self.errors:
+            print(f"   Błędy: {len(self.errors)}")
+        
+        if self.comparison_data:
+            fake_diff = abs(self.comparison_data['avg_fake_score']['BBC'] - self.comparison_data['avg_fake_score']['Gazeta Prawna'])
+            time_diff = abs(self.comparison_data['performance']['BBC'] - self.comparison_data['performance']['Gazeta Prawna'])
+            
+            print(f"\n🔍 WNIOSKI Z PORÓWNANIA:")
+            print(f"   • Różnica w ryzyku dezinformacji: {fake_diff:.1f}%")
+            print(f"   • Różnica w czasie analizy: {time_diff:.2f}s")
+            
+            if fake_diff > 10:
+                print(f"   • ⚠️ Znacząca różnica w NLP między językami")
+            if time_diff > 2:
+                print(f"   • ⏱️ Analiza polskiego języka wymaga więcej czasu")
+        
+        print(f"\n📁 Raporty wygenerowane:")
+        print(f"   HTML: {html_report}")
+        print(f"   Tekst: {text_report}")
+        print(f"{'='*70}")
+        
+        return passed > total * 0.7
+
+
+def main():
+    """Główna funkcja"""
+    print("🎯 TruthScan AI - Testy porównawcze BBC vs Gazeta Prawna")
+    print("=" * 70)
+    
+    tester = TruthScanComparativeTester()
+    
+    # Uruchom testy
+    success = tester.run_comparative_tests()
+    
+    print("\n" + "=" * 70)
+    if success:
+        print("✅ TESTY ZAKOŃCZONE SUKCESEM!")
+    else:
+        print("⚠️ TESTY WYKAZAŁY PROBLEMY - sprawdź raport")
+    print("=" * 70)
+    
+    print("\n📋 Otwórz raport HTML w przeglądarce:")
+    print(f"   file://{os.path.abspath('truthscan_comparative_report.html')}")
+    
+    return success
+
+
+if __name__ == "__main__":
+    try:
+        import requests
+    except ImportError:
+        print("❌ Brak biblioteki 'requests'")
+        print("💡 Zainstaluj: pip install requests")
+        exit(1)
+    
+    main()

TruthScan AI_frontend/.gitignore

@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

TruthScan AI_frontend/README.md

@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

TruthScan AI_frontend/Uruchamianie.md

@@ -0,0 +1,30 @@
+ThruScan AI - Instrukcja uruchomienia
+
+ Wymagania wstępne
+- Windows 10+
+- Node.js 18+ 
+- Python 3.9+
+
+Backend
+- py -3.11 -m pip install –opgrade pip
+- py -3.11 -m pip install -r requirements.txt
+
+Uruchomienie aplikacji w wierszu polecenia (przykładowa ścieżka) D:\>Studia\Semestr 7\PRACA DYPLOMOWA\TruthScan AI\TruthScan AI_backend
+python -m uvicorn app.main:app 
+
+Test API w przeglądarce lub w programie Postman:
+http://127.0.0.1:8000/news/BBC
+http://127.0.0.1:8000/sources - zwraca słownik wszystkich źródeł RSS
+http://127.0.0.1:8000/news/BBC - pobiera 5 najnowszych artykułów
+http://127.0.0.1:8000/emotion-stats/BBC - oblicza rozkład sentymentu
+http://127.0.0.1:8000/stream-news/bbc - strumieniuje artykuły w czasie rzeczywistym (Server-Sent Events)
+
+Testowanie endpointów w Swagger (OpenAPI) dla backendu
+http://localhost:8000/docs
+
+Frontend
+- npm install
+
+Uruchomienie aplikacji w wierszu polecenia (przykładowa ścieżka) D:\>Studia\Semestr 7\PRACA DYPLOMOWA\TruthScan AI\TruthScan AI_frontend
+npm run dev
+http://localhost:3000

TruthScan AI_frontend/app/TipModel.tsx

@@ -0,0 +1,90 @@
+/**
+ * Komponent modalny wyświetlający edukacyjne porady dla użytkownika.
+ */
+
+"use client";
+
+import { useEffect } from "react";
+
+type TipModalProps = {
+  title: string;
+  body: string;
+  linkHref: string;
+  linkLabel: string;
+  onClose: () => void;
+};
+
+export default function TipModal({
+  title,
+  body,
+  linkHref,
+  linkLabel,
+  onClose,
+}: TipModalProps) {
+  // ESC + blokada scrolla z kompensacją paska
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => e.key === "Escape" && onClose();
+    window.addEventListener("keydown", onKey);
+
+    const docEl = document.documentElement;
+    const bodyEl = document.body;
+    const scrollbarWidth = window.innerWidth - docEl.clientWidth;
+    const prevOverflow = bodyEl.style.overflow;
+    const prevPaddingRight = bodyEl.style.paddingRight;
+
+    if (scrollbarWidth > 0) bodyEl.style.paddingRight = `${scrollbarWidth}px`;
+    bodyEl.style.overflow = "hidden";
+
+    return () => {
+      window.removeEventListener("keydown", onKey);
+      bodyEl.style.overflow = prevOverflow;
+      bodyEl.style.paddingRight = prevPaddingRight;
+    };
+  }, [onClose]);
+
+  return (
+    <div role="dialog" aria-modal="true" className="fixed inset-0 z-[100] flex items-center justify-center">
+      <button
+        aria-label="Close"
+        onClick={onClose}
+        className="absolute inset-0 bg-black/60"
+      />
+      <div className="relative z-[101] w-[92vw] max-w-xl rounded-lg bg-white dark:bg-slate-900 shadow-lg border border-slate-200/60 dark:border-slate-700/60">
+        <div className="flex items-start justify-between p-4 border-b border-slate-200/60 dark:border-slate-700/60">
+          <h3 className="text-base font-semibold">{title}</h3>
+          <button
+            onClick={onClose}
+            className="rounded p-1 text-slate-500 hover:text-slate-700 dark:text-slate-300 dark:hover:text-white focus:outline-none focus:ring-2 focus:ring-blue-500"
+          >
+            ✕
+          </button>
+        </div>
+
+        <div className="p-4 text-sm text-slate-700 dark:text-slate-200">
+          <p className="mb-3 leading-relaxed">{body}</p>
+          <a
+            href={linkHref}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="inline-flex items-center gap-1 text-blue-600 dark:text-blue-400 underline hover:no-underline"
+          >
+            <svg className="h-4 w-4" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.7" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+              <path d="M14 3h7v7M10 14 21 3" />
+              <path d="M21 14v7h-7M3 10v11h11" />
+            </svg>
+            {linkLabel}
+          </a>
+        </div>
+
+        <div className="p-3 flex justify-end">
+          <button
+            onClick={onClose}
+            className="px-3 py-1.5 rounded bg-blue-600 hover:bg-blue-700 text-white text-sm font-medium"
+          >
+            OK
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

TruthScan AI_frontend/app/api/fetch-article-content/route.ts

@@ -0,0 +1,198 @@
+/**
+ * Endpoint API odpowiedzialny za pobieranie i ekstrakcję treści artykułów.
+ */
+
+import { NextResponse } from 'next/server';
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const url = searchParams.get('url');
+
+  if (!url) {
+    return NextResponse.json({ error: 'URL is required' }, { status: 400 });
+  }
+
+  try {
+    console.log('Fetching BBC article from:', url);
+
+    const response = await fetch(url, {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+      }
+    });
+    
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    
+    const html = await response.text();
+    
+    // Ekstrakcja treści (BBC → fallback ogólny)
+    let text = extractBBCArticleContent(html);
+    if (!text || text.length < 300) {
+      text = extractGenericArticleContent(html);
+    }
+    
+    console.log('Extracted article length:', text.length);
+    
+    return NextResponse.json({ 
+      content: text,
+      success: true,
+      contentLength: text.length
+    });
+    
+  } catch (error) {
+    console.error('Error fetching article:', error);
+    return NextResponse.json({ 
+      error: 'Failed to fetch article content',
+      success: false 
+    }, { status: 500 });
+  }
+}
+
+  /**
+ * Ekstrakcja treści artykułu dla serwisu BBC.
+ */
+function extractBBCArticleContent(html: string): string {
+  console.log('Extracting BBC article content...');
+  const bbcSelectors = [
+    /<main[^>]*id="main-content"[^>]*>([\s\S]*?)<\/main>/i,
+    /<article[^>]*>([\s\S]*?)<\/article>/i,
+    /<div[^>]*data-component="text-block"[^>]*>([\s\S]*?)<\/div>/gi,
+    /<div[^>]*class="[^"]*ssrcss-1ocoo3l-Wrap[^"]*"[^>]*>([\s\S]*?)<\/div>/gi,
+    /<div[^>]*class="[^"]*story-body[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+    /<div[^>]*data-entityid="story-content"[^>]*>([\s\S]*?)<\/div>/i,
+  ];
+
+  for (const regex of bbcSelectors) {
+    const matches = html.match(regex);
+    if (matches) {
+      let content = '';
+      if (regex.flags.includes('g')) {
+        for (let i = 0; i < matches.length; i++) {
+          content += matches[i] + ' ';
+        }
+      } else {
+        content = matches[1] || matches[0];
+      }
+      
+      const cleaned = cleanArticleContent(content);
+      if (cleaned.length > 200) {
+        console.log('Found BBC content with selector');
+        return cleaned;
+      }
+    }
+  }
+
+  return '';
+}
+
+/**
+ * Ogólna metoda ekstrakcji treści dla pozostałych serwisów.
+ */
+function extractGenericArticleContent(html: string): string {
+  console.log('Using generic extraction...');
+  
+  const genericSelectors = [
+    /<article[^>]*>([\s\S]*?)<\/article>/i,
+    /<div[^>]*class="[^"]*article[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+    /<div[^>]*class="[^"]*content[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+    /<div[^>]*class="[^"]*post-content[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+    /<div[^>]*class="[^"]*entry-content[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+    /<div[^>]*class="[^"]*story[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+  ];
+
+  for (const regex of genericSelectors) {
+    const match = html.match(regex);
+    if (match && match[1]) {
+      const content = cleanArticleContent(match[1]);
+      if (content.length > 200) {
+        return content;
+      }
+    }
+  }
+
+  const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+  if (bodyMatch && bodyMatch[1]) {
+    return cleanAndFilterContent(bodyMatch[1]);
+  }
+
+  return cleanAndFilterContent(html);
+}
+
+/**
+ * Usuwa znaczniki HTML oraz elementy nienależące do treści artykułu.
+ */
+function cleanArticleContent(html: string): string {
+  return html
+    .replace(/<script\b[\s\S]*?<\/script>/gi, '')
+    .replace(/<style\b[\s\S]*?<\/style>/gi, '')
+    .replace(/<nav\b[\s\S]*?<\/nav>/gi, '')
+    .replace(/<header\b[\s\S]*?<\/header>/gi, '')
+    .replace(/<footer\b[\s\S]*?<\/footer>/gi, '')
+    .replace(/<aside\b[\s\S]*?<\/aside>/gi, '')
+    .replace(/<form\b[\s\S]*?<\/form>/gi, '')
+    .replace(/<button\b[\s\S]*?<\/button>/gi, '')
+    .replace(/<a\b[^>]*>(.*?)<\/a>/gi, '$1')
+    .replace(/<img\b[^>]*>/gi, '')
+    .replace(/<figure\b[\s\S]*?<\/figure>/gi, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#x27;/g, "'")
+    .replace(/&#039;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    .trim();
+}
+
+/**
+ * Dodatkowe filtrowanie treści:
+ * usuwa szum informacyjny (nawigacja, reklamy, social media).
+ */
+function cleanAndFilterContent(text: string): string {
+  const noisePatterns = [
+    /menu|navigation|nav|home|skip to content|skip to main|main menu/gi,
+    /header|footer|sidebar|side-bar|panel boczny/gi,
+    /share|udostępnij|comment|komentarz|like|follow|subscribe/gi,
+    /facebook|twitter|instagram|youtube|linkedin|social media/gi,
+    /reklama|advertisement|ads?|sponsored|promoted|partner/gi,
+    /bbc\.com|bbc\.co\.uk|bbc news|bbc sport|bbc iplayer/gi,
+    /home news|sport|business|innovation|culture|arts|travel/gi,
+    /weather|climate|audio|video|live|newsletters|podcast/gi,
+    /copyright|all rights reserved|privacy policy|terms of use/gi,
+    /cookie policy|contact us|about us|o nas|regulamin/gi,
+  ];
+
+  let cleaned = text;
+  
+  const lines = cleaned.split('\n').filter(line => {
+    const trimmed = line.trim();
+    if (trimmed.length < 20) return false;
+    
+    for (const pattern of noisePatterns) {
+      if (pattern.test(trimmed)) {
+        return false;
+      }
+    }
+    
+    const hasProperSentence = /[.!?]/.test(trimmed) && trimmed.split(' ').length > 5;
+    const isNoise = /^[^a-zA-Z]*$/.test(trimmed) || trimmed.includes('<!--') || trimmed.includes('-->');
+    
+    return hasProperSentence && !isNoise;
+  });
+
+  cleaned = lines.join('\n');
+  
+  for (const pattern of noisePatterns) {
+    cleaned = cleaned.replace(pattern, '');
+  }
+
+  return cleaned
+    .replace(/\s+/g, ' ')
+    .replace(/([.!?])\s+/g, '$1\n\n')
+    .trim()
+    .substring(0, 10000);
+}

TruthScan AI_frontend/app/dashboard/components/ArticlesModal.tsx

@@ -0,0 +1,83 @@
+/**
+ * Modal wyświetlający strumień artykułów dla wybranego źródła informacyjnego.
+ */
+
+"use client";
+
+import { useEffect } from "react";
+import LiveNewsFeed from "../../../components/LiveNewsFeed";
+
+import type { Lang } from "../../../lib/types";
+
+interface ArticlesModalProps {
+  source: string;
+  language: Lang;
+  onClose: () => void;
+}
+
+export default function ArticlesModal({
+  source,
+  language,
+  onClose,
+}: ArticlesModalProps) {
+  // ESC + blokada scrolla z kompensacją paska
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => e.key === "Escape" && onClose();
+    window.addEventListener("keydown", onKey);
+
+    const docEl = document.documentElement;
+    const bodyEl = document.body;
+    const scrollbarWidth = window.innerWidth - docEl.clientWidth;
+    const prevOverflow = bodyEl.style.overflow;
+    const prevPaddingRight = bodyEl.style.paddingRight;
+
+    if (scrollbarWidth > 0) bodyEl.style.paddingRight = `${scrollbarWidth}px`;
+    bodyEl.style.overflow = "hidden";
+
+    return () => {
+      window.removeEventListener("keydown", onKey);
+      bodyEl.style.overflow = prevOverflow;
+      bodyEl.style.paddingRight = prevPaddingRight;
+    };
+  }, [onClose]);
+
+  return (
+    <div role="dialog" aria-modal="true" className="fixed inset-0 z-[100] flex items-center justify-center">
+      <button
+        aria-label="Close"
+        onClick={onClose}
+        className="absolute inset-0 bg-black/60"
+      />
+      
+      <div className="relative z-[101] w-[95vw] max-w-6xl h-[85vh] rounded-lg bg-white dark:bg-slate-900 shadow-lg border border-slate-200/60 dark:border-slate-700/60 flex flex-col">
+        <div className="flex items-start justify-between p-4 border-b border-slate-200/60 dark:border-slate-700/60 flex-shrink-0">
+          <h3 className="text-lg font-semibold">
+            {language === "pl" ? "Artykuły z" : language === "no" ? "Artikler fra" : "Articles from"} <span className="text-blue-600">{source}</span>
+          </h3>
+          <button
+            onClick={onClose}
+            className="rounded p-1 text-slate-500 hover:text-slate-700 dark:text-slate-300 dark:hover:text-white focus:outline-none focus:ring-2 focus:ring-blue-500"
+          >
+            ✕
+          </button>
+        </div>
+
+        <div className="flex-1 overflow-y-auto p-4">
+          <LiveNewsFeed 
+            source={source}
+            language={language}
+          />
+        </div>
+
+        <div className="p-3 border-t border-slate-200/60 dark:border-slate-700/60 flex justify-end flex-shrink-0">
+          <button
+            onClick={onClose}
+            className="px-4 py-2 rounded bg-blue-600 hover:bg-blue-700 text-white text-sm font-medium"
+          >
+            {language === "pl" ? "Zamknij" : language === "no" ? "Lukk" : "Close"}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

TruthScan AI_frontend/app/dashboard/components/ChartsSection.tsx

@@ -0,0 +1,282 @@
+/**
+ * Sekcja dashboardu odpowiedzialna za wizualizację danych analitycznych.
+ *
+ * Komponent integruje:
+ * - wykres sentymentu emocjonalnego,
+ * - wykres prawdopodobieństwa fake newsów według źródeł,
+ * - mechanizm leniwego ładowania i cache po stronie klienta,
+ * - modal z listą artykułów dla wybranego źródła.
+ */
+
+"use client";
+
+import { useRef, useEffect, useState } from "react";
+import SourceSelector from "../../../components/SourceSelector";
+import EmotionalPieChart from "../../../components/EmotionalPieChart";
+import FakeNewsBarChart from "../../../components/FakeNewsBarChart";
+import ProgressBar from "../../../components/ProgressBar";
+import { useDashboardCharts } from "../../hooks/useDashboardCharts";
+import locales from "../../../lib/locales";
+import MiniSpinner from "./MiniSpinner";
+import ArticlesModal from "./ArticlesModal";
+
+import type { Lang } from "../../../lib/types";
+
+interface Props {
+  language: Lang;
+  selectedSource: string;
+  setSelectedSource: (source: string) => void;
+}
+
+const DASHBOARD_CHARTS_KEY = "dashboard:charts";
+
+type ChartsCache = {
+  barData: any[];
+  emotionData: any[];
+  totalSources: number;
+};
+
+export default function ChartsSection({
+  language,
+  selectedSource,
+  setSelectedSource,
+}: Props) {
+  const [isClient, setIsClient] = useState(false);
+  const [cachedCharts, setCachedCharts] = useState<ChartsCache | null>(null);
+  
+  const {
+    barData,
+    emotionData,
+    progressCount,
+    progressPct,
+    chartsLoading,
+    chartsError,
+    chartsStarted,
+    loadCharts,
+    totalSources,
+    hasBars,
+    hasEmos,
+  } = useDashboardCharts(language);
+
+  const [showArticlesModal, setShowArticlesModal] = useState(false);
+  const chartsSectionRef = useRef<HTMLDivElement | null>(null);
+  const hasLoadedRef = useRef(false); 
+
+  useEffect(() => {
+    setIsClient(true);
+    
+    import("../../../app/stores/newsCache").then(({ useNewsCache }) => {
+      const cache = useNewsCache.getState();
+      setCachedCharts(cache.get<ChartsCache>(DASHBOARD_CHARTS_KEY));
+    });
+  }, []);
+
+  useEffect(() => {
+    if (!isClient || hasLoadedRef.current) return;
+    
+    const el = chartsSectionRef.current;
+    if (!el) return;
+
+    if (cachedCharts) {
+      console.log("✅ Używam cache dla wykresów");
+      return;
+    }
+
+    hasLoadedRef.current = true;
+    
+    if ("IntersectionObserver" in window) {
+      const io = new IntersectionObserver(
+        (entries) => {
+          if (entries.some((e) => e.isIntersecting)) {
+            console.log("🚀 Ładuję wykresy (intersection)...");
+            loadCharts();
+            io.disconnect();
+          }
+        },
+        { threshold: 0.05, rootMargin: "200px 0px" } 
+      );
+      io.observe(el);
+      return () => io.disconnect();
+    } else {
+      const t = setTimeout(() => {
+        console.log("🚀 Ładuję wykresy (timeout)...");
+        loadCharts();
+      }, 300);
+      return () => clearTimeout(t);
+    }
+  }, [isClient, cachedCharts, loadCharts]);
+
+  useEffect(() => {
+    if (!isClient || !chartsStarted || chartsLoading || chartsError || (!hasBars && !hasEmos)) {
+      return;
+    }
+
+    if (!barData?.length && !emotionData?.length) return;
+
+    import("../../../app/stores/newsCache").then(({ useNewsCache }) => {
+      const cache = useNewsCache.getState();
+      
+      const currentCache = cache.get<ChartsCache>(DASHBOARD_CHARTS_KEY);
+      const areDataEqual = 
+        JSON.stringify(currentCache?.barData) === JSON.stringify(barData) &&
+        JSON.stringify(currentCache?.emotionData) === JSON.stringify(emotionData);
+        
+      if (areDataEqual) return;
+
+      const payload: ChartsCache = {
+        barData,
+        emotionData,
+        totalSources,
+      };
+      cache.set(DASHBOARD_CHARTS_KEY, payload);
+      setCachedCharts(payload); 
+    });
+  }, [
+    isClient,
+    chartsStarted,
+    chartsLoading,
+    chartsError,
+    hasBars,
+    hasEmos,
+    barData,
+    emotionData,
+    totalSources,
+  ]);
+
+  if (!isClient) {
+    return (
+      <section className="grid grid-cols-1 lg:grid-cols-3 gap-6 items-stretch">
+        <div className="space-y-4 lg:col-span-1">
+          <div className="rounded-lg bg-gray-100 p-4 shadow dark:bg-gray-800">
+            <div className="h-6 bg-gray-300 dark:bg-gray-700 rounded mb-2 w-1/2 animate-pulse"></div>
+            <div className="h-10 bg-gray-300 dark:bg-gray-700 rounded animate-pulse"></div>
+          </div>
+          <div className="min-h-[320px] rounded-lg bg-gray-100 p-4 shadow dark:bg-gray-800 animate-pulse"></div>
+        </div>
+        <div className="lg:col-span-2 bg-gray-100 dark:bg-gray-800 p-4 rounded-lg shadow min-h-[420px] lg:min-h-[480px] animate-pulse"></div>
+      </section>
+    );
+  }
+
+  const effectiveBarData = cachedCharts?.barData ?? barData;
+  const effectiveEmotionData = cachedCharts?.emotionData ?? emotionData;
+  const effectiveTotalSources = cachedCharts?.totalSources ?? totalSources;
+
+  const effectiveHasBars = cachedCharts
+    ? cachedCharts.barData.length > 0
+    : hasBars;
+  const effectiveHasEmos = cachedCharts
+    ? cachedCharts.emotionData.length > 0
+    : hasEmos;
+
+  const effectiveChartsStarted = cachedCharts ? true : chartsStarted;
+  const effectiveChartsLoading = cachedCharts ? false : chartsLoading;
+  const effectiveProgressCount = cachedCharts
+    ? effectiveTotalSources
+    : progressCount;
+  const effectiveProgressPct = cachedCharts ? 100 : progressPct;
+
+  const t = locales[language] ?? locales.pl;
+
+  return (
+    <>
+      <section
+        ref={chartsSectionRef}
+        className="grid grid-cols-1 lg:grid-cols-3 gap-6 items-stretch"
+      >
+        <div className="space-y-4 lg:col-span-1">
+          <div className="rounded-lg bg-gray-100 p-4 shadow dark:bg-gray-800">
+            <h2 className="mb-2 text-lg font-semibold">{t.selectSource}</h2>
+            <SourceSelector
+              selectedSource={selectedSource}
+              setSelectedSource={setSelectedSource}
+              language={language}
+              locales={locales}
+            />
+
+            {selectedSource && (
+              <button
+                onClick={() => setShowArticlesModal(true)}
+                className="mt-3 w-full rounded-lg bg-blue-600 px-4 py-2 font-medium text-white transition-colors hover:bg-blue-700"
+              >
+                📰{" "}
+                {language === "pl" ? "Pokaż artykuły" : language === "no" ? "Vis artikler" : "Show articles"}
+              </button>
+            )}
+          </div>
+
+          <div className="min-h-[320px] rounded-lg bg-gray-100 p-4 shadow dark:bg-gray-800">
+            {effectiveChartsStarted && (
+              <ProgressBar
+                progressCount={effectiveProgressCount}
+                totalSources={effectiveTotalSources}
+                progressPct={effectiveProgressPct}
+                language={language}
+              />
+            )}
+
+            {chartsError ? (
+              <div className="text-sm text-red-400">{chartsError}</div>
+            ) : effectiveHasEmos ? (
+              <EmotionalPieChart
+                data={effectiveEmotionData}
+                title={
+                  language === "pl"
+                    ? "Emocje w artykułach"
+                    : language === "no"
+                    ? "Følelser i artikler"
+                    : "Emotions in Articles"
+                }
+              />
+            ) : effectiveChartsLoading ? (
+              <MiniSpinner
+                text={
+                  language === "pl"
+                    ? "Ładuję wykres emocji…"
+                    : language === "no"
+                    ? "Laster emosjonskart…"
+                    : "Loading emotions chart…"
+                }
+              />
+            ) : null}
+          </div>
+        </div>
+
+        <div className="lg:col-span-2 bg-gray-100 dark:bg-gray-800 p-4 rounded-lg shadow flex flex-col h-full">
+          {effectiveChartsStarted && (
+            <ProgressBar
+              progressCount={effectiveProgressCount}
+              totalSources={effectiveTotalSources}
+              progressPct={effectiveProgressPct}
+              language={language}
+            />
+          )}
+
+          {chartsError ? (
+            <div className="text-sm text-red-400">{chartsError}</div>
+          ) : effectiveHasBars ? (
+            <FakeNewsBarChart data={effectiveBarData} title={t.fakeNewsSources} />
+          ) : effectiveChartsLoading ? (
+            <MiniSpinner
+              text={
+                language === "pl"
+                  ? "Ładuję wykres źródeł…"
+                  : language === "no"
+                  ? "Laster kildekart…"
+                  : "Loading sources chart…"
+              }
+            />
+          ) : null}
+        </div>
+      </section>
+
+      {showArticlesModal && (
+        <ArticlesModal
+          source={selectedSource}
+          language={language}
+          onClose={() => setShowArticlesModal(false)}
+        />
+      )}
+    </>
+  );
+}

TruthScan AI_frontend/app/dashboard/components/DashboardHeader.tsx

@@ -0,0 +1,62 @@
+/**
+ * Nagłówek dashboardu prezentujący nazwę systemu
+ * oraz opis jego funkcjonalności w zależności od języka interfejsu.
+ */
+
+"use client";
+
+import type { Lang } from "../../../lib/types";
+
+interface Props {
+  language: Lang;
+  hydrated: boolean;
+}
+
+export default function DashboardHeader({ language, hydrated }: Props) {
+  const isPl = language === "pl";
+  const isNo = language === "no";
+
+  return (
+    <div className="bg-gray-100 dark:bg-gray-900 p-5 rounded-xl shadow-md">
+      {/* Gradientowy nagłówek AI */}
+      <h2
+        className="text-5xl font-extrabold tracking-tight
+        bg-gradient-to-r from-blue-500 via-purple-500 to-pink-500
+        text-transparent bg-clip-text
+        drop-shadow-[0_0_10px_rgba(56,189,248,0.35)]
+        flex items-center gap-3"
+      >
+        <span className="text-4xl"></span>
+        TruthScan AI
+      </h2>
+
+      <p
+        className="mt-3 text-gray-700 dark:text-gray-300 text-base"
+        suppressHydrationWarning
+      >
+        {hydrated
+          ? isPl
+            ? "Narzędzie do analizy wiadomości z wielu źródeł, które pomaga ocenić emocjonalny wydźwięk treści oraz wykrywać potencjalnie wprowadzające w błąd informacje."
+            : isNo
+            ? "Verktøy for nyhetsanalyse fra flere kilder som hjelper deg å vurdere den emosjonelle tonen og oppdage potensielt villedende informasjon."
+            : "A tool for analyzing news from multiple sources that helps assess emotional tone and detect potentially misleading content."
+          : ""}
+      </p>
+
+      <p
+        className="text-sm mt-1 text-gray-600 dark:text-gray-400 max-w-3xl"
+        suppressHydrationWarning
+      >
+        {hydrated
+          ? isPl
+            ? "W oparciu o automatyczną analizę treści TruthScan AI prezentuje wyniki w formie przejrzystych wykresów i zestawienia artykułów."
+            : isNo
+            ? "Basert på automatisk innholdsanalyse presenterer TruthScan AI resultater i form av tydelige diagrammer og artikkeloversikter."
+            : "Using automated content analysis, TruthScan AI presents results through clear charts and structured article summaries."
+          : ""}
+      </p>
+    </div>
+  );
+}
+
+

TruthScan AI_frontend/app/dashboard/components/MiniSpinner.tsx

@@ -0,0 +1,19 @@
+/**
+ * Mały komponent prezentacyjny wyświetlający wskaźnik ładowania
+ * wraz z krótkim komunikatem tekstowym.
+ */
+
+"use client";
+
+interface Props {
+  text: string;
+}
+
+export default function MiniSpinner({ text }: Props) {
+  return (
+    <div className="flex items-center gap-2 text-sm text-gray-400">
+      <div className="h-4 w-4 rounded-full border-2 border-blue-500 border-t-transparent animate-spin" />
+      {text}
+    </div>
+  );
+}

TruthScan AI_frontend/app/dashboard/components/SourceComparison.tsx

@@ -0,0 +1,53 @@
+/**
+ * Sekcja dashboardu umożliwiająca porównanie wielu źródeł informacyjnych.
+ *
+ * Renderuje zestaw bloków źródeł, pozwalając użytkownikowi analizować
+ * i porównywać dane pochodzące z różnych serwisów informacyjnych.
+ */
+
+"use client";
+
+import { useState } from "react";
+import SourceBlock from "../../../components/SourceBlock";
+import locales from "../../../lib/locales";
+
+import type { Lang } from "../../../lib/types";
+
+interface Props {
+	language: Lang;
+}
+
+const ALL_SOURCES = [
+	"BBC", "CNN", "NYTimes", "Guardian", "AlJazeera",
+	"Money", "PolsatNews", "GazetaPrawna", "SpidersWeb", "Bankier",
+	"NRK", "VG", "Dagbladet", "Aftenposten",
+] as const;
+
+export default function SourceComparison({ language }: Props) {
+	const [compareSources, setCompareSources] = useState<string[]>([
+		...ALL_SOURCES,
+	]);
+
+	const updateCompareSource = (idx: number, src: string) =>
+		setCompareSources((prev) => prev.map((s, i) => (i === idx ? src : s)));
+
+	return (
+		<section>
+			<h2 className="text-2xl font-semibold mb-4">
+				{language === "pl" ? "Porównanie źródeł" : language === "no" ? "Kildesammenligning" : "Sources comparison"}
+			</h2>
+
+			<div className="grid grid-cols-1 md:grid-cols-2 xl:grid-cols-3 gap-6">
+				{compareSources.map((src, idx) => (
+					<SourceBlock
+						key={`${idx}-${src}`}
+						source={src}
+						onChangeSource={(next) => updateCompareSource(idx, next)}
+						language={language}
+						locales={locales}
+					/>
+				))}
+			</div>
+		</section>
+	);
+}

TruthScan AI_frontend/app/dashboard/error.tsx

@@ -0,0 +1,33 @@
+/**
+ * Komponent obsługi błędów dla widoku dashboardu.
+ */
+
+"use client";
+
+interface Props {
+  error: Error & { digest?: string };
+  reset: () => void;
+}
+
+export default function ErrorPage({ error, reset }: Props) {
+  return (
+    <div className="p-6 text-red-500">
+      <h2 className="text-2xl font-bold mb-4">
+        ❌ {typeof window !== "undefined" && localStorage.getItem("lang") === "en"
+          ? "An error occurred in the dashboard"
+          : "Wystąpił błąd w dashboardzie"}
+      </h2>
+
+      <p>{error.message}</p>
+
+      <button
+        className="mt-4 bg-red-600 text-white px-4 py-2 rounded"
+        onClick={() => reset()}
+      >
+        🔁 {typeof window !== "undefined" && localStorage.getItem("lang") === "en"
+          ? "Try again"
+          : "Spróbuj ponownie"}
+      </button>
+    </div>
+  );
+}

TruthScan AI_frontend/app/dashboard/loading.tsx

@@ -0,0 +1,21 @@
+/**
+ * Komponent stanu ładowania dla widoku dashboardu.
+ */
+
+export default function Loading() {
+  return (
+    <div className="flex flex-col items-center justify-center h-screen text-gray-600 dark:text-gray-300">
+      
+      <div className="relative flex items-center justify-center">
+        <div className="animate-spin rounded-full h-16 w-16 border-t-4 border-b-4 border-transparent border-t-blue-500 border-b-purple-500"></div>
+        <div className="absolute animate-pulse bg-gradient-to-r from-blue-500 to-purple-500 rounded-full h-6 w-6"></div>
+      </div>
+
+      <p className="mt-6 text-xl font-semibold bg-gradient-to-r from-blue-500 to-purple-500 bg-clip-text text-transparent animate-pulse">
+        ⏳ Ładowanie dashboardu...
+      </p>
+    </div>
+  );
+}
+
+

TruthScan AI_frontend/app/dashboard/page.tsx

@@ -0,0 +1,71 @@
+/**
+ * Główna strona dashboardu analitycznego aplikacji.
+ */
+
+"use client";
+
+import { useEffect, useState } from "react";
+import { RefreshCcw } from "lucide-react";
+import { useLanguage } from "../hooks/useLanguage";
+import DashboardHeader from "./components/DashboardHeader";
+import ChartsSection from "./components/ChartsSection";
+import SourceComparison from "./components/SourceComparison";
+
+
+
+import { useNewsCache, newsKey } from "../../app/stores/newsCache";
+
+export default function DashboardPage() {
+  const [hydrated, setHydrated] = useState(false);
+  const { language } = useLanguage();
+  const [selectedSource, setSelectedSource] = useState("BBC");
+  const cache = useNewsCache();
+  const [reloadKey, setReloadKey] = useState(0); 
+  const REFRESH_TEXT = {
+  pl: "Odśwież ",
+  en: "Refresh ",
+  no: "Oppdater ",
+} as const;
+
+  
+  useEffect(() => {
+    setHydrated(true);
+  }, []);
+
+  const handleRefresh = () => {
+    // Usunięcie danych z cache i ponowne pobranie
+    cache.del(newsKey(selectedSource, language));
+    setReloadKey((k) => k + 1);
+  };
+
+  return (
+    <div className="mx-auto w-full space-y-6 p-6 text-foreground bg-gradient-to-br from-blue-50 via-indigo-100 to-indigo-500 dark:from-gray-900 dark:via-gray-800 dark:to-blue-900">
+      <div className="flex items-center justify-between gap-3">
+        <DashboardHeader language={language} hydrated={hydrated} />
+        <div className="flex items-center gap-2">
+          <button
+          onClick={handleRefresh}
+          className="flex items-center gap-2 rounded-lg bg-white/80 px-3 py-1.5 text-sm
+             text-slate-900 shadow-sm hover:bg-white dark:bg-slate-700
+             dark:text-slate-100 dark:hover:bg-slate-700 transition-colors"
+          title={REFRESH_TEXT[language]}
+        >
+          <span className="text-lg">↺</span>
+          {REFRESH_TEXT[language]}
+        </button>
+        </div>
+      </div>
+
+      <ChartsSection
+        key={`${selectedSource}:${reloadKey}`} 
+        language={language}
+        selectedSource={selectedSource}
+        setSelectedSource={setSelectedSource}
+      />
+
+      <SourceComparison language={language} />
+    </div>
+  );
+}
+
+ 

TruthScan AI_frontend/app/error.tsx

@@ -0,0 +1,39 @@
+/**
+ * Globalny komponent obsługi błędów aplikacji (Next.js App Router).
+ */
+
+"use client";
+
+interface Props {
+  error: Error & { digest?: string };
+  reset: () => void;
+}
+
+export default function GlobalError({ error, reset }: Props) {
+
+  const lang =
+    typeof window !== "undefined" && localStorage.getItem("lang") === "en"
+      ? "en"
+      : "pl";
+
+  return (
+    <html lang="pl"> 
+      <body className="p-6 text-red-500 bg-gray-50 dark:bg-gray-900"> 
+        <h2 className="text-3xl font-bold mb-4">
+          ❌ {lang === "en"
+            ? "An unexpected error occurred"
+            : "Wystąpił nieoczekiwany błąd"}
+        </h2>
+
+        <p className="mb-4">{error.message}</p>
+
+        <button
+          className="mt-2 bg-red-600 text-white px-4 py-2 rounded hover:bg-red-700 transition"
+          onClick={() => reset()}
+        >
+          🔁 {lang === "en" ? "Try again" : "Spróbuj ponownie"}
+        </button>
+      </body>
+    </html>
+  );
+}

TruthScan AI_frontend/app/hooks/useArticleContent.ts

@@ -0,0 +1,121 @@
+/**
+ * Hook odpowiedzialny za pobieranie i wstępne czyszczenie treści artykułów.
+ */
+
+import { useCallback } from 'react';
+
+export const useArticleContent = () => {
+  const fetchFullContent = useCallback(async (url: string): Promise<string> => {
+    try {
+      console.log("🔄 Pobieranie pełnej treści z:", url);
+      // Pobranie treści artykułu przez proxy (obejście CORS)
+      const proxyUrl = `https://api.codetabs.com/v1/proxy?quest=${encodeURIComponent(url)}`;
+    
+    const response = await fetch(proxyUrl, {
+      headers: {
+        'Accept': 'text/html,application/xhtml+xml,application/xml',
+        'Accept-Language': 'pl,en-US;q=0.7,en;q=0.3',
+      },
+      signal: AbortSignal.timeout(15000),
+    });
+      
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    
+    const html = await response.text();
+    
+    if (!html || html.length < 500) {
+      console.log("⚠️ Treść zbyt krótka lub pusta");
+      return "";
+    }
+      // Parsowanie HTML i usunięcie elementów nienależących do treści
+      const parser = new DOMParser();
+      const doc = parser.parseFromString(html, 'text/html');
+      
+      const elementsToRemove = doc.querySelectorAll(
+        'script, style, nav, header, footer, aside, .ad, .ads, [class*="ad-"], .navigation, .menu, .social, .share, .comments, iframe'
+      );
+      elementsToRemove.forEach(el => el.remove());
+      
+      // Próba znalezienia głównej treści artykułu
+      const contentSelectors = [
+        'article',
+        '.article-content',
+        '.post-content',
+        '.entry-content',
+        '.story-content',
+        '.news-content',
+        '.content-area',
+        '[role="main"]',
+        'main',
+        '.content',
+        '.story__content',
+        '.article-body',
+        '.article-text',
+        '.post-body',
+        '.news-body',
+        '.td-post-content',
+        '.single-content',
+        '.article__content'
+      ];
+      
+      let contentElement = null;
+      for (const selector of contentSelectors) {
+        const element = doc.querySelector(selector);
+        if (element && element.textContent && element.textContent.length > 200) {
+          contentElement = element;
+          break;
+        }
+      }
+      
+      let content = '';
+      if (contentElement) {
+        content = contentElement.textContent || '';
+      } else {
+        const paragraphs = doc.querySelectorAll('p');
+        const paragraphTexts = Array.from(paragraphs)
+          .map(p => p.textContent?.trim())
+          .filter(text => text && text.length > 50) 
+          .slice(0, 20); 
+        
+        content = paragraphTexts.join('\n\n');
+      }
+      
+      content = content
+        .replace(/\s+/g, ' ')
+        .replace(/\n\s*\n/g, '\n\n')
+        .trim();
+      
+      if (content.length < 100) {
+        console.log("⚠️ Za mało treści, próbuję fallback...");
+        const metaDescription = doc.querySelector('meta[name="description"]')?.getAttribute('content');
+        const ogDescription = doc.querySelector('meta[property="og:description"]')?.getAttribute('content');
+        
+        content = metaDescription || ogDescription || doc.title || '';
+      }
+      
+      console.log("✅ Pobrano treść, długość:", content.length);
+      return content;
+      
+    } catch (error) {
+      console.error("❌ Błąd pobierania treści:", error);
+      
+      try {
+        console.log("🔄 Próba bez proxy...");
+        const directResponse = await fetch(url, {
+          mode: 'no-cors', 
+          headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+          }
+        });
+        
+        // Fallback w przypadku błędu pobierania treści
+        return "";
+      } catch (directError) {
+        console.error("❌ Błąd przy próbie bez proxy:", directError);
+        return "";
+      }
+    }
+  }, []);
+
+  return { fetchFullContent };
+};

TruthScan AI_frontend/app/hooks/useCachedEmotionStats.ts

@@ -0,0 +1,63 @@
+/**
+ * Hook pobierający statystyki emocji dla źródła z wykorzystaniem cache po stronie klienta.
+ */
+
+"use client";
+
+import { useEffect, useState } from "react";
+import { useNewsCache, statsKey } from "../../app/stores/newsCache";
+
+type EmotionStats = {
+  source: string;
+  total_articles: number;
+  emotion_counts: {
+    Pozytywne: number;
+    Neutralne: number;
+    Negatywne: number;
+  };
+  emotion_percentages: {
+    Pozytywne: number;
+    Neutralne: number;
+    Negatywne: number;
+  };
+};
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || "http://127.0.0.1:8000";
+
+export function useCachedEmotionStats(source: string) {
+  const cache = useNewsCache();
+  const [data, setData] = useState<EmotionStats | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!source) return;
+
+    const key = statsKey(source);
+    const cached = cache.get<EmotionStats>(key);
+
+    // Jeśli dane są w cache, pomijamy request do API
+    if (cached) {
+      setData(cached);
+      setLoading(false);
+      return;
+    }
+
+    (async () => {
+      try {
+        setLoading(true);
+        const res = await fetch(`${API_URL}/emotion-stats/${encodeURIComponent(source)}`);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const json = (await res.json()) as EmotionStats;
+        setData(json);
+        cache.set(key, json);
+      } catch (e: any) {
+        setError(e?.message ?? "fetch error");
+      } finally {
+        setLoading(false);
+      }
+    })();
+  }, [source]);
+
+  return { data, loading, error };
+}

TruthScan AI_frontend/app/hooks/useDashboardCharts.ts

@@ -0,0 +1,102 @@
+/**
+ * Hook odpowiedzialny za pobieranie i agregację danych do wykresów dashboardu.
+ */
+
+import { useCallback, useRef, useState } from "react";
+import { fetchOneSource, NewsData } from "../../lib/fetchNews";
+import type { Lang } from "../../lib/types";
+
+const ALL_SOURCES = [
+  "BBC", "CNN", "NYTimes", "Guardian", "AlJazeera",
+  "Money", "PolsatNews", "GazetaPrawna", "SpidersWeb", "Bankier",
+  "NRK", "VG", "Dagbladet", "Aftenposten",
+] as const;
+
+export function useDashboardCharts(language: Lang) {
+  const [barData, setBarData] = useState<{ label: string; value: number }[]>([]);
+  const [emotionData, setEmotionData] = useState<{ name: string; value: number }[]>([]);
+  const [progressCount, setProgressCount] = useState(0);
+  const [chartsLoading, setChartsLoading] = useState(false);
+  const [chartsError, setChartsError] = useState<string | null>(null);
+  
+  // Struktury w useRef – pozwalają aktualizować dane bez nadmiarowych re-renderów
+  const barsMapRef = useRef<Map<string, number>>(new Map());
+  const emosMapRef = useRef<Record<string, number>>({ 
+    POSITIVE: 0, NEGATIVE: 0, NEUTRAL: 0 
+  });
+  const chartsStartedRef = useRef(false);
+
+  const progressPct = Math.round((progressCount / ALL_SOURCES.length) * 100);
+
+  const normalizeSent = (s: string): "POSITIVE" | "NEGATIVE" | "NEUTRAL" => {
+    const k = (s || "").trim().toUpperCase();
+    if (k === "POZYTYWNE" || k === "POSITIVE" || k === "POSITIVT") return "POSITIVE";
+    if (k === "NEGATYWNE" || k === "NEGATIVE" || k === "NEGATIVT") return "NEGATIVE";
+    if (k === "NEUTRALNE" || k === "NEUTRAL"  || k === "NØYTRALT") return "NEUTRAL";
+    return "NEUTRAL";
+  };
+
+  const refreshChartsFromRefs = () => {
+    const order = new Map(ALL_SOURCES.map((s, i) => [s as string, i]));
+    const arr = Array.from(barsMapRef.current.entries()).map(([label, value]) => ({
+      label, value,
+    }));
+    arr.sort((a, b) => (order.get(a.label) ?? 999) - (order.get(b.label) ?? 999));
+    setBarData(arr);
+
+    const emoArr = [
+      { name: "POSITIVE", value: emosMapRef.current.POSITIVE },
+      { name: "NEUTRAL", value: emosMapRef.current.NEUTRAL },
+      { name: "NEGATIVE", value: emosMapRef.current.NEGATIVE }
+    ];
+    setEmotionData(emoArr);
+  };
+
+  const loadCharts = useCallback(async () => {
+    if (chartsStartedRef.current) return;
+    chartsStartedRef.current = true;
+    setChartsLoading(true);
+    setChartsError(null);
+    setProgressCount(0);
+    barsMapRef.current.clear();
+    emosMapRef.current = { POSITIVE: 0, NEGATIVE: 0, NEUTRAL: 0 };
+
+    const promises = ALL_SOURCES.map(async (src) => {
+      try {
+        const { news, emotions } = await fetchOneSource(src, language);
+
+        if (news) {
+          barsMapRef.current.set(news.source, parseFloat(news.fake_news));
+        }
+
+        for (const [emotionKey, count] of Object.entries(emotions)) {
+          const normalized = normalizeSent(emotionKey);
+          emosMapRef.current[normalized] = (emosMapRef.current[normalized] || 0) + (count as number);
+        }
+
+        refreshChartsFromRefs();
+        setProgressCount((c) => c + 1);
+      } catch (error) {
+        console.error(`Error loading source ${src}:`, error);
+        setProgressCount((c) => c + 1);
+      }
+    });
+
+    await Promise.allSettled(promises);
+    setChartsLoading(false);
+  }, [language]);
+
+  return {
+    barData,
+    emotionData,
+    progressCount,
+    progressPct,
+    chartsLoading,
+    chartsError,
+    chartsStarted: chartsStartedRef.current,
+    loadCharts,
+    totalSources: ALL_SOURCES.length,
+    hasBars: barData.length > 0,
+    hasEmos: emotionData.length > 0,
+  };
+}

TruthScan AI_frontend/app/hooks/useFavicon.ts

@@ -0,0 +1,73 @@
+/**
+ * Hook odpowiedzialny za ustalenie i fallback ikonki (favicon) źródła artykułu.
+ */
+
+import { useState, useEffect, useMemo } from 'react';
+import { Article } from '../../lib/fetchNews';
+
+const SOURCE_DOMAINS: Record<string, string> = {
+  bbc: "bbc.com",
+  cnn: "cnn.com",
+  nytimes: "nytimes.com",
+  newyorktimes: "nytimes.com",
+  guardian: "theguardian.com",
+  theguardian: "theguardian.com",
+  aljazeera: "aljazeera.com",
+  dziennik: "dziennik.pl",
+  polsatnews: "polsatnews.pl",
+  gazetaprawna: "gazetaprawna.pl",
+  spidersweb: "spidersweb.pl",
+  bankier: "bankier.pl",
+};
+
+function normalizeKey(s?: string) {
+  return (s || "")
+    .toLowerCase()
+    .normalize("NFKD")
+    .replace(/[''`"]/g, "")
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim()
+    .replace(/\s+/g, "");
+}
+
+export function useFavicon(article: Article) {
+  // Lista potencjalnych favicon z fallbackami
+  const candidates = useMemo(() => {
+    const cand: string[] = [];
+    const s2 = (host: string) => `https://www.google.com/s2/favicons?domain=${host}&sz=64`;
+    const ddg = (host: string) => `https://icons.duckduckgo.com/ip3/${host}.ico`;
+
+    if (article.link) {
+      try {
+        const raw = article.link.startsWith("http") ? article.link : `https://${article.link}`;
+        const host = new URL(raw).hostname;
+        if (host) cand.push(s2(host), ddg(host));
+      } catch {}
+    }
+
+    const srcKey = normalizeKey(article.source);
+    const mapped = SOURCE_DOMAINS[srcKey];
+    if (mapped) cand.push(s2(mapped), ddg(mapped));
+    if (!mapped && srcKey) {
+      cand.push(s2(`${srcKey}.com`), ddg(`${srcKey}.com`));
+      cand.push(s2(`${srcKey}.pl`), ddg(`${srcKey}.pl`));
+    }
+
+    return [...new Set(cand)];
+  }, [article]);
+
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const currentSrc = candidates[currentIndex];
+  const sourceInitial = (article.source || "?").slice(0, 1).toUpperCase();
+
+  useEffect(() => setCurrentIndex(0), [candidates.join("|")]);
+
+  const nextFavicon = () => setCurrentIndex(prev => prev + 1);
+
+  return {
+    faviconSrc: currentSrc,
+    sourceInitial,
+    hasFavicon: !!currentSrc,  
+    nextFavicon  
+  };
+}

TruthScan AI_frontend/app/hooks/useLanguage.ts

@@ -0,0 +1,54 @@
+/**
+ * Hook zarządzający językiem interfejsu aplikacji.
+ */
+
+import { useState, useEffect, useRef } from 'react';
+
+import type { Lang } from "../../lib/types";
+
+const isLang = (v: unknown): v is Lang => v === "pl" || v === "en" || v === "no";
+
+export function useLanguage() {
+  const [language, setLanguage] = useState<Lang>("pl");
+  const langRef = useRef<Lang>("pl");
+
+  useEffect(() => {
+    const htmlLang = document.documentElement.lang;
+    if (isLang(htmlLang)) {
+      setLanguage(htmlLang);
+      langRef.current = htmlLang;
+    }
+
+    const stored = localStorage.getItem("lang");
+    if (isLang(stored)) {
+      setLanguage(stored);
+      langRef.current = stored;
+    }
+
+    // Synchronizacja zmiany języka między komponentami i kartami przeglądarki
+    const onCustom = (e: Event) => {
+      const next = (e as CustomEvent).detail;
+      if (isLang(next)) {
+        setLanguage(next);
+        langRef.current = next;
+      }
+    };
+
+    const onStorage = (e: StorageEvent) => {
+      if (e.key === "lang" && isLang(e.newValue)) {
+        setLanguage(e.newValue);
+        langRef.current = e.newValue;
+      }
+    };
+
+    window.addEventListener("app:langchange", onCustom as EventListener);
+    window.addEventListener("storage", onStorage);
+    
+    return () => {
+      window.removeEventListener("app:langchange", onCustom as EventListener);
+      window.removeEventListener("storage", onStorage);
+    };
+  }, []);
+
+  return { language, langRef };
+}

TruthScan AI_frontend/app/hooks/useNewsCache.ts

@@ -0,0 +1,87 @@
+/**
+ * Hook pobierający listę newsów dla wybranego źródła.
+ * Wykorzystuje cache po stronie klienta w celu ograniczenia liczby zapytań do API.
+ */
+
+import { useEffect, useState } from "react";
+import { useNewsCache, newsKey } from "../../app/stores/newsCache";
+import type { Lang } from "../../lib/types";
+
+type Article = {
+  title: string;
+  link: string;
+  summary: string;
+  published: string;
+  source: string;
+  sentiment: string;       
+  fake_probability: number;
+  sentiment_score?: number;
+};
+
+type NewsResponse = { source: string; articles: Article[] };
+
+export function useCachedNews(source: string, lang: Lang = "pl") {
+  const [data, setData] = useState<Article[] | null>(null);
+  const [loading, setLoading] = useState<boolean>(true);
+  const [error, setError] = useState<string | null>(null);
+  const cache = useNewsCache();
+
+  useEffect(() => {
+    let mounted = true;
+    const key = newsKey(source, lang);
+
+    // Odczyt danych z cache przed wykonaniem zapytania HTTP
+    const cached = cache.get<Article[]>(key);
+    if (cached) {
+      setData(cached);
+      setLoading(false);
+      return;
+    }
+
+    (async () => {
+      try {
+        setLoading(true);
+        const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/news/${encodeURIComponent(source)}?lang=${lang}`);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const json: NewsResponse = await res.json();
+        const articles = json.articles ?? [];
+        if (!mounted) return;
+        setData(articles);
+
+        // Zapis danych w cache po poprawnym pobraniu
+        cache.set(key, articles); 
+      } catch (e: any) {
+        if (!mounted) return;
+        setError(e?.message ?? "fetch error");
+      } finally {
+        if (mounted) setLoading(false);
+      }
+    })();
+
+    return () => {
+      // Zabezpieczenie przed aktualizacją stanu po odmontowaniu komponentu
+      mounted = false;
+    };
+  }, [source, lang]);
+
+  const refresh = async () => {
+    const key = newsKey(source, lang);
+    cache.del(key);
+    setData(null);
+    setLoading(true);
+    try {
+      const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/news/${encodeURIComponent(source)}?lang=${lang}`);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const json: NewsResponse = await res.json();
+      const articles = json.articles ?? [];
+      setData(articles);
+      cache.set(key, articles);
+    } catch (e: any) {
+      setError(e?.message ?? "fetch error");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return { data, loading, error, refresh };
+}

TruthScan AI_frontend/app/hooks/useNewsStream.ts

@@ -0,0 +1,128 @@
+/**
+ * Hook obsługujący strumieniowe pobieranie newsów (SSE) dla wybranego źródła.
+ */
+
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import type { Article } from "@/lib/fetchNews";
+import { useNewsCache, newsKey } from "../../app/stores/newsCache";
+import type { Lang } from "../../lib/types";
+
+type StreamState = {
+  articles: Article[];
+  loading: boolean;
+  error: string | null;
+  progress: number;
+  total: number;
+};
+
+export function useNewsStream(source: string, lang: Lang = "pl", limit: number = 5): StreamState {
+  const [state, setState] = useState<StreamState>({
+    articles: [],
+    loading: true,
+    error: null,
+    progress: 0,
+    total: 0,
+  });
+
+  const esRef = useRef<EventSource | null>(null);
+  const cache = useNewsCache();
+
+  useEffect(() => {
+    if (!source) return;
+
+    const cacheKey = newsKey(source, lang);
+    const cached = cache.get<Article[]>(cacheKey);
+
+     // Jeżeli dane są w cache, pomijamy połączenie SSE
+    if (cached && cached.length > 0) {
+      setState({
+        articles: cached,
+        loading: false,
+        error: null,
+        progress: cached.length,
+        total: cached.length,
+      });
+      return;
+    }
+
+    setState({
+      articles: [],
+      loading: true,
+      error: null,
+      progress: 0,
+      total: 0,
+    });
+
+    const apiBase = process.env.NEXT_PUBLIC_API_URL || "http://127.0.0.1:8000";
+    const es = new EventSource(`${apiBase}/stream-news/${encodeURIComponent(source)}?lang=${lang}`);
+    esRef.current = es;
+
+    let collected: Article[] = [];
+
+    const handleMeta = (e: MessageEvent) => {
+      try {
+        const { total } = JSON.parse(e.data);
+        setState((s) => ({ ...s, total: Math.min(total ?? 0, limit) }));
+      } catch {
+      }
+    };
+
+    const handleBackendError = (e: MessageEvent) => {
+      const msg = (() => {
+        try {
+          return JSON.parse(e.data)?.message || "Backend error";
+        } catch {
+          return "Backend error";
+        }
+      })();
+      setState((s) => ({ ...s, loading: false, error: msg }));
+    };
+
+    const handleMessage = (ev: MessageEvent) => {
+      try {
+        const article = JSON.parse(ev.data) as Article;
+        collected.push(article);
+        setState((s) => {
+          const next = [...s.articles, article].slice(0, limit);
+          return {
+            ...s,
+            articles: next,
+            progress: Math.min(next.length, s.total || limit),
+          };
+        });
+      } catch {
+      }
+    };
+
+    const handleDone = () => {
+      setState((s) => ({ ...s, loading: false }));
+       // Zapis pełnego wyniku do cache po zakończeniu strumienia
+      if (collected.length > 0) {
+        cache.set(cacheKey, collected);
+      }
+      es.close();
+    };
+
+    const handleError = () => {
+      setState((s) => ({ ...s, loading: false, error: "Stream error" }));
+      es.close();
+    };
+
+    es.addEventListener("meta", handleMeta);
+    es.addEventListener("backend_error", handleBackendError);
+    es.addEventListener("done", handleDone);
+    es.onmessage = handleMessage;
+    es.onerror = handleError;
+
+    return () => {
+      es.removeEventListener("meta", handleMeta);
+      es.removeEventListener("backend_error", handleBackendError);
+      es.removeEventListener("done", handleDone);
+      es.close();
+    };
+  }, [source, lang, limit]);
+
+  return state;
+}

TruthScan AI_frontend/app/hooks/usePDFExport.ts

@@ -0,0 +1,160 @@
+/**
+ * Hook umożliwiający eksport wybranego fragmentu interfejsu do PDF (druk przeglądarki).
+ */
+
+import { useCallback } from 'react';
+
+interface PDFOptions {
+  title?: string;
+  margins?: string;
+}
+
+export const usePDFExport = (
+  componentRef: React.RefObject<HTMLDivElement | null>,
+  options: PDFOptions = {}
+) => {
+  const {
+    title = 'ThruScan_Analysis',
+    margins = '15mm'
+  } = options;
+
+  const handlePrint = useCallback((): Promise<void> => {
+    return new Promise((resolve, reject) => {
+      if (!componentRef.current) {
+        reject(new Error('Component reference is not available'));
+        return;
+      }
+
+      const printWindow = window.open('', '_blank');
+
+      // Fallback: jeśli okno nie może zostać otwarte (blokada popupów),
+      // zapisujemy zawartość jako statyczny plik HTML
+      if (!printWindow) {
+        const content = componentRef.current.innerHTML;
+        const blob = new Blob([`
+          <!DOCTYPE html>
+          <html lang="pl">
+          <head>
+            <meta charset="UTF-8">
+            <title>${title}</title>
+            <style>
+              body { font-family: Arial, sans-serif; margin: 20px; }
+            </style>
+          </head>
+          <body>${content}</body>
+          </html>
+        `], { type: 'text/html' });
+        
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = `${title}.html`;
+        link.click();
+        URL.revokeObjectURL(url);
+        resolve();
+        return;
+      }
+
+      try {
+        const content = componentRef.current.cloneNode(true) as HTMLDivElement;
+
+        // Usunięcie elementów interaktywnych z eksportowanego widoku
+        const interactiveElements = content.querySelectorAll('button, input, select, textarea, .pdf-generator-controls');
+        interactiveElements.forEach(el => el.remove());
+
+        const style = `
+          <style>
+            @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+            
+            @page {
+              margin: ${margins};
+              size: A4;
+            }
+            
+            body {
+              margin: 0;
+              padding: 0;
+              font-family: 'Inter', 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+              -webkit-print-color-adjust: exact;
+              print-color-adjust: exact;
+              color: #000;
+              background: white;
+              line-height: 1.4;
+            }
+            
+            * {
+              -webkit-print-color-adjust: exact !important;
+              color-adjust: exact !important;
+            }
+            
+            .pdf-content {
+              margin: 0 !important;
+              padding: 0 !important;
+              box-shadow: none !important;
+              border: none !important;
+            }
+            
+            table { 
+              width: 100%; 
+              border-collapse: collapse; 
+              margin: 10px 0;
+            }
+            
+            th, td { 
+              border: 1px solid #ddd; 
+              padding: 8px; 
+              text-align: left; 
+            }
+            
+            th { 
+              background-color: #f5f5f5 !important; 
+            }
+          </style>
+        `;
+
+        printWindow.document.write(`
+          <!DOCTYPE html>
+          <html lang="pl">
+            <head>
+              <title>${title}</title>
+              <meta charset="UTF-8">
+              <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+              ${style}
+            </head>
+            <body>
+              ${content.innerHTML}
+            </body>
+          </html>
+        `);
+        
+        printWindow.document.close();
+
+        setTimeout(() => {
+          printWindow.focus();
+          printWindow.print();
+
+          const checkPrint = setInterval(() => {
+            if (printWindow.closed) {
+              clearInterval(checkPrint);
+              resolve();
+            }
+          }, 100);
+
+          setTimeout(() => {
+            if (!printWindow.closed) {
+              printWindow.close();
+              resolve();
+            }
+          }, 10000);
+          
+        }, 1000);
+        
+      } catch (error) {
+        printWindow?.close();
+        reject(error);
+      }
+    });
+  }, [componentRef, title, margins]);
+
+  return handlePrint;
+};

TruthScan AI_frontend/app/hooks/useSentiment.ts

@@ -0,0 +1,40 @@
+/**
+ * Hook mapujący wynik analizy sentymentu na etykietę i kolor interfejsu.
+ */
+
+import { useMemo } from 'react';
+
+export interface SentimentResult {
+  label: string;
+  color: string;
+}
+
+export function useSentiment(sentiment: string, language: "pl" | "en" | "no"): SentimentResult {
+  return useMemo(() => {
+    const sentimentUpper = (sentiment || "").toUpperCase();
+
+    // Normalizacja wyniku sentymentu do formy prezentacyjnej (UI)
+    const label = language === "pl"
+      ? sentimentUpper.includes("POS") ? "Pozytywne"
+      : sentimentUpper.includes("NEG") ? "Negatywne"
+      : "Neutralne"
+      : language === "no"
+      ? sentimentUpper.includes("POS") ? "Positivt"
+      : sentimentUpper.includes("NEG") ? "Negativt"
+      : "Nøytralt"
+      : sentimentUpper.includes("POS") ? "Positive"
+      : sentimentUpper.includes("NEG") ? "Negative"
+      : "Neutral";
+
+    const positiveLabel = language === "pl" ? "Pozytywne" : language === "no" ? "Positivt" : "Positive";
+    const negativeLabel = language === "pl" ? "Negatywne" : language === "no" ? "Negativt" : "Negative";
+
+    const color = label === positiveLabel
+      ? "text-green-500"
+      : label === negativeLabel
+      ? "text-red-500"
+      : "text-blue-400";
+
+    return { label, color };
+  }, [sentiment, language]);
+}

TruthScan AI_frontend/app/layout.tsx

@@ -0,0 +1,28 @@
+/**
+ * Główny layout aplikacji frontendowej (Next.js App Router).
+ */
+
+import "../styles/globals.css";
+import NavBar from "../components/NavBar";
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="pl">
+      <body>
+        <div className="content-overlay min-h-screen flex flex-col">
+          <NavBar />
+
+          <main className="flex-1">{children}</main>
+
+          <footer className="text-center p-4 text-sm bg-white/80 dark:bg-gray-900/80 text-gray-600 dark:text-gray-400">
+            © {new Date().getFullYear()} TruthScan AI
+          </footer>
+        </div>
+      </body>
+    </html>
+  );
+}

TruthScan AI_frontend/app/page.tsx

@@ -0,0 +1,331 @@
+/**
+ * Strona główna aplikacji TruthScan AI.
+ */
+
+"use client";
+
+import { useEffect, useState } from "react";
+import { motion, AnimatePresence } from "framer-motion";
+import locales from "../lib/locales";
+import TipModal from "../app/TipModel";
+import type { Lang } from "../lib/types";
+
+export default function HomePage() {
+
+  const [language, setLanguage] = useState<Lang>("pl");
+  const [activeTip, setActiveTip] = useState<number | null>(null);
+
+  useEffect(() => {
+    // Synchronizacja języka interfejsu (localStorage + zdarzenie globalne)
+    const stored = localStorage.getItem("lang");
+    if (stored === "pl" || stored === "en" || stored === "no") setLanguage(stored as Lang);
+
+    const onLangChange = (e: Event) => {
+      const detail = (e as CustomEvent).detail;
+      if (detail === "pl" || detail === "en" || detail === "no") setLanguage(detail as Lang);
+    };
+    window.addEventListener("app:langchange", onLangChange as EventListener);
+    
+    return () => window.removeEventListener("app:langchange", onLangChange as EventListener);
+  }, []);
+
+  const t = locales[language];
+    const T = (pl: string, no: string, en: string) =>
+    language === "pl" ? pl : language === "no" ? no : en;
+
+  const tips = [
+    {
+      pl: "Sprawdź źródło artykułu",
+      no: "Sjekk kilden til artikkelen",
+      en: "Check the article source",
+      morePl: "Zwróć uwagę na autora i wydawcę. Sprawdź czy strona ma sekcję 'O nas', dane kontaktowe i politykę redakcyjną. Unikaj anonimowych blogów i stron bez informacji o zespole. Prawdziwe media zwykle podają swoje dane i mają przejrzystą strukturę własności.",
+      moreNo: "Vær oppmerksom på forfatteren og utgiveren. Sjekk om nettstedet har en 'Om oss'-seksjon, kontaktinformasjon og redaksjonell policy. Unngå anonyme blogger og nettsteder uten teaminformasjon. Legitime medier oppgir vanligvis sine data og har en gjennomsiktig eierskapsstruktur.",
+      moreEn: "Pay attention to the author and publisher. Check if the site has an 'About us' section, contact details and editorial policy. Avoid anonymous blogs and sites without team information. Legitimate media usually provide their data and have transparent ownership structure.",
+      link: { href: "https://demagog.org.pl/edukacja/", labelPl: "Demagog: Jak weryfikować źródła", labelNo: "Demagog: Slik verifiserer du kilder", labelEn: "Demagog: How to verify sources" },
+      icon: "🔍"
+    },
+    {
+      pl: "Analizuj emocjonalny język",
+      no: "Analyser emosjonelt språk",
+      en: "Analyze emotional language",
+      morePl: "Teksty pełne wykrzykników, CAPS LOCKA i ostrych epitetów często manipulują emocjami. Prawdziwe newsy starają się być neutralne. Zwróć uwagę na clickbaitowe nagłówki obiecujące szokujące rewelacje bez pokrycia w treści.",
+      moreNo: "Tekster fulle av utropstegn, STORE BOKSTAVER og harde epiteter manipulerer ofte følelser. Ekte nyheter prøver å være nøytrale. Vær oppmerksom på clickbait-overskrifter som lover sjokkerende avsløringer uten innhold.",
+      moreEn: "Texts full of exclamation marks, ALL CAPS and harsh epithets often manipulate emotions. Real news tries to be neutral. Pay attention to clickbait headlines promising shocking revelations without substance.",
+      link: { href: "https://www.snopes.com/collections/fact-checking-101/", labelPl: "Snopes: Podstawy fact-checkingu", labelNo: "Snopes: Grunnleggende fakta-sjekk", labelEn: "Snopes: Fact-checking basics" },
+      icon: "🎭"
+    },
+    {
+      pl: "Weryfikuj w wielu źródłach",
+      no: "Verifiser i flere kilder",
+      en: "Verify in multiple sources",
+      morePl: "Nie polegaj na jednym źródle. Sprawdź tę samą informację w co najmniej 2-3 wiarygodnych mediach. Użyj wyszukiwarki z operatorami jak 'site:.gov.pl' lub 'site:.edu'. Sprawdź datę publikacji - stare newsy często są udostępniane jako aktualne.",
+      moreNo: "Ikke stol på én kilde. Sjekk samme informasjon i minst 2-3 pålitelige medier. Bruk søkemotorer med operatorer som 'site:.gov.no' eller 'site:.edu'. Sjekk publiseringsdatoen - gamle nyheter deles ofte som nye.",
+      moreEn: "Don't rely on one source. Check the same information in at least 2-3 reliable media. Use search engines with operators like 'site:.gov' or 'site:.edu'. Check the publication date - old news is often shared as current.",
+      link: { href: "https://factcheck.afp.com/", labelPl: "AFP Fact Check", labelNo: "AFP Fact Check", labelEn: "AFP Fact Check" },
+      icon: "📡"
+    },
+    {
+      pl: "Sprawdź dowody i cytaty",
+      no: "Sjekk bevis og sitater",
+      en: "Check evidence and quotes",
+      morePl: "Prawdziwe artykuły zawierają konkretne dane, statystyki, cytaty ekspertów i odnośniki do badań. Fake newsy operują ogólnikami i emocjami. Sprawdź czy cytowane osoby rzeczywiście istnieją i czy zostały poprawnie przytoczone.",
+      moreNo: "Ekte artikler inneholder spesifikke data, statistikk, ekspertsitater og henvisninger til forskning. Falske nyheter opererer med generaliseringer og følelser. Sjekk om siterte personer faktisk eksisterer og ble korrekt sitert.",
+      moreEn: "Real articles contain specific data, statistics, expert quotes and references to research. Fake news operates on generalizations and emotions. Check if quoted people actually exist and were correctly cited.",
+      link: { href: "https://www.politifact.com/", labelPl: "PolitiFact: Weryfikacja faktów", labelNo: "PolitiFact: Faktaverifisering", labelEn: "PolitiFact: Fact verification" },
+      icon: "📊"
+    },
+    {
+      pl: "Uważaj na deepfakes i manipulacje",
+      no: "Vær forsiktig med deepfakes og manipulasjoner",
+      en: "Beware of deepfakes and manipulations",
+      morePl: "Coraz częściej spotykamy zmontowane zdjęcia, filmy i nagrania audio. Sprawdź oryginalne źródło materiału. Użyj narzędzi do odwrotnego wyszukiwania obrazów. Zwróć uwagę na nienaturalne ruchy twarzy w filmach.",
+      moreNo: "Vi møter stadig mer manipulerte bilder, videoer og lydopptak. Sjekk den originale kilden til materialet. Bruk verktøy for omvendt bildesøk. Vær oppmerksom på unaturlige ansiktsbevegelser i videoer.",
+      moreEn: "We increasingly encounter edited photos, videos and audio recordings. Check the original source of the material. Use reverse image search tools. Pay attention to unnatural facial movements in videos.",
+      link: { href: "https://euvsdisinfo.eu/", labelPl: "EU vs Disinfo: Walka z dezinformacją", labelNo: "EU vs Disinfo: Kamp mot desinformasjon", labelEn: "EU vs Disinfo: Fighting disinformation" },
+      icon: "🛸"
+    }
+  ];
+
+   const sources = [
+    { href: "https://demagog.org.pl", label: "Demagog", tag: "PL",},
+    { href: "https://konkret24.tvn24.pl", label: "Konkret24", tag: "PL",},
+    { href: "https://fakehunter.pap.pl", label: "FakeHunter", tag: "PL",},
+    { href: "https://euvsdisinfo.eu", label: "EU vs Disinfo", tag: "EU",},
+    { href: "https://www.snopes.com/", label: "Snopes", tag: "EN",},
+    { href: "https://www.politifact.com/", label: "PolitiFact", tag: "EN",},
+    { href: "https://factcheck.afp.com/", label: "AFP Fact Check", tag: "EN",},
+    { href: "https://www.factcheck.org/", label: "FactCheck.org", tag: "EN",  },
+  ];
+
+  const features = [
+    {
+      icon: "🤖",
+      title: T("Analiza AI", "AI-analyse", "AI Analysis"),
+      description: T(
+        "Zaawansowane modele NLP do analizy sentymentu i wykrywania dezinformacji",
+        "Avanserte NLP-modeller for sentimentanalyse og oppdagelse av desinformasjon",
+        "Advanced NLP models for sentiment analysis and misinformation detection"
+      )
+    },
+    {
+      icon: "⚡",
+      title: T("Analiza w Czasie Rzeczywistym", "Sanntidsanalyse", "Real-time Analysis"),
+      description: T(
+        "Natychmiastowe przetwarzanie najnowszych wiadomości ze strumieni RSS",
+        "Umiddelbar behandling av siste nyheter fra RSS-strømmer",
+        "Instant processing of latest news from RSS feeds"
+      )
+    },
+    {
+      icon: "🌐",
+      title: T("Wiele Źródeł", "Flere kilder", "Multiple Sources"),
+      description: T(
+        "Porównuj wiadomości z 10+ zaufanych źródeł krajowych i międzynarodowych",
+        "Sammenlign nyheter fra 10+ pålitelige innenlandske og internasjonale kilder",
+        "Compare news from 10+ trusted domestic and international sources"
+      )
+    },
+    {
+      icon: "📊",
+      title: T("Dashboard z Wykresami", "Dashbord med diagrammer", "Chart Dashboard"),
+      description: T(
+        "Interaktywne wizualizacje danych i statystyki emocjonalne",
+        "Interaktive datavisualiseringer og emosjonell statistikk",
+        "Interactive data visualizations and emotional statistics"
+      )
+    }
+  ];
+
+  return (
+  <div className="min-h-screen bg-gradient-to-b from-blue-200 via-purple-100/80 to-pink-100/30 dark:from-gray-900 dark:via-gray-800 dark:to-gray-700 text-gray-900 dark:text-gray-100 font-sans">
+
+    <section className="relative py-16 px-4 md:px-8 flex items-center justify-center">
+      <motion.div 
+        initial={{ opacity: 0, y: 30 }}
+        animate={{ opacity: 1, y: 0 }}
+        transition={{ duration: 0.8 }}
+        className="relative z-10 text-center space-y-8 w-full max-w-4xl mx-auto"
+      >
+        <motion.h1 
+          initial={{ opacity: 0, y: 20 }}
+          animate={{ opacity: 1, y: 0 }}
+          transition={{ delay: 0.2 }}
+          className="text-5xl md:text-6xl lg:text-7xl font-bold bg-gradient-to-r from-blue-600 via-purple-600 to-pink-600 bg-clip-text text-transparent"
+        >
+          TruthScan AI
+        </motion.h1>
+        
+        <motion.p 
+          initial={{ opacity: 0, y: 20 }}
+          animate={{ opacity: 1, y: 0 }}
+          transition={{ delay: 0.3 }}
+          className="text-xl md:text-2xl text-gray-700 dark:text-gray-300 max-w-2xl mx-auto"
+        >
+          {T(
+            "Inteligentny system do analizy wiarygodności newsów i wykrywania dezinformacji",
+            "Intelligent system for troverdighetanalyse av nyheter og oppdagelse av desinformasjon",
+            "Intelligent system for news credibility analysis and misinformation detection"
+          )}
+        </motion.p>
+
+        <motion.div
+          initial={{ opacity: 0, y: 20 }}
+          animate={{ opacity: 1, y: 0 }}
+          transition={{ delay: 0.4 }}
+          className="flex justify-center gap-8 py-4"
+        >
+          <div className="text-center">
+            <div className="text-2xl font-bold text-blue-600 dark:text-blue-400">10+</div>
+            <div className="text-sm text-gray-600 dark:text-gray-400">
+              {T("Źródeł", "Kilder", "Sources")}
+            </div>
+          </div>
+          <div className="text-center">
+            <div className="text-2xl font-bold text-purple-600 dark:text-purple-400">2s</div>
+            <div className="text-sm text-gray-600 dark:text-gray-400">
+              {T("Analiza", "Analyse", "Analysis")}
+            </div>
+          </div>
+          <div className="text-center">
+            <div className="text-2xl font-bold text-pink-600 dark:text-pink-400">AI</div>
+            <div className="text-sm text-gray-600 dark:text-gray-400">
+              {T("Modele NLP", "NLP-modeller", "NLP Models")}
+            </div>
+          </div>
+        </motion.div>
+
+        <motion.div
+          initial={{ opacity: 0, y: 20 }}
+          animate={{ opacity: 1, y: 0 }}
+          transition={{ delay: 0.5 }}
+          className="flex flex-col sm:flex-row gap-4 justify-center pt-4"
+        >
+          <a
+            href="/dashboard"
+            className="bg-gradient-to-r from-blue-600 to-purple-600 hover:from-blue-700 hover:to-purple-700 text-white px-8 py-3 rounded-lg text-lg font-semibold transition-all hover:scale-105 shadow-lg"
+          >
+            {T("Przejdź do Dashboardu →", "Gå til dashbordet →", "Go to Dashboard →")}
+          </a>
+          
+        </motion.div>
+      </motion.div>
+    </section>
+
+    <section id="features" className="py-12 px-4 md:px-8">
+      <div className="container mx-auto max-w-6xl">
+        <motion.div 
+          initial={{ opacity: 0, y: 20 }}
+          whileInView={{ opacity: 1, y: 0 }}
+          viewport={{ once: true }}
+          className="text-center mb-12"
+        >
+          <h2 className="text-4xl font-bold mb-4 text-gray-800 dark:text-gray-100">
+            {T(" Dlaczego TruthScan AI?", " Hvorfor TruthScan AI?", " Why TruthScan AI?")}
+          </h2>
+          <p className="text-gray-700 dark:text-gray-300 max-w-2xl mx-auto">
+            {T(
+              "Nowoczesne narzędzie wspierające krytyczne myślenie",
+              "Moderne verktøy som støtter kritisk tenkning",
+              "Modern tool supporting critical thinking"
+            )}
+          </p>
+        </motion.div>
+        
+        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-6">
+          {features.map((feature, index) => (
+            <motion.div
+              key={feature.title}
+              initial={{ opacity: 0, y: 20 }}
+              whileInView={{ opacity: 1, y: 0 }}
+              viewport={{ once: true }}
+              transition={{ delay: index * 0.1 }}
+              className="bg-white/80 dark:bg-gray-800/80 backdrop-blur-sm p-6 rounded-xl shadow-lg border border-gray-200/50 dark:border-gray-700/50"
+            >
+              <div className="text-4xl mb-4">{feature.icon}</div>
+              <h3 className="text-lg font-bold mb-3 text-gray-800 dark:text-gray-100">
+                {feature.title}
+              </h3>
+              <p className="text-gray-700 dark:text-gray-300 text-sm">
+                {feature.description}
+              </p>
+            </motion.div>
+          ))}
+        </div>
+      </div>
+    </section>
+
+    <section className="py-12 px-4 md:px-8">
+      <div className="container mx-auto max-w-6xl">
+        <div className="grid grid-cols-1 lg:grid-cols-2 gap-8">
+          
+          <div className="space-y-6">
+            <h2 className="text-2xl font-bold text-gray-800 dark:text-gray-100">
+              {T("🔍 Jak rozpoznać fake newsy?", "🔍 Hvordan gjenkjenne falske nyheter?", "🔍 How to Spot Fake News")}
+            </h2>
+            
+            <div className="space-y-3">
+              {tips.map((tip, i) => (
+                <button
+                  key={i}
+                  onClick={() => setActiveTip(i)}
+                  className="w-full flex items-start gap-3 p-4 bg-white/80 dark:bg-gray-800/80 backdrop-blur-sm rounded-lg shadow hover:shadow-md transition-all text-left border border-gray-200/50 dark:border-gray-700/50"
+                >
+                  <div className="text-xl">{tip.icon}</div>
+                  <div className="flex-1">
+                    <h3 className="font-semibold text-gray-800 dark:text-gray-100">
+                      {language === "pl" ? tip.pl : language === "no" ? tip.no : tip.en}
+                    </h3>
+                    <p className="text-gray-600 dark:text-gray-400 text-sm mt-1">
+                      {T("Kliknij, aby dowiedzieć się więcej", "Klikk for å lære mer", "Click to learn more")}
+                    </p>
+                  </div>
+                </button>
+              ))}
+            </div>
+          </div>
+
+          <div className="space-y-6">
+            <h2 className="text-2xl font-bold text-gray-800 dark:text-gray-100">
+              {T("📚 Polecane źródła", "📚 Anbefalte kilder", "📚 Recommended Sources")}
+            </h2>
+            
+            <div className="grid grid-cols-1 gap-3">
+              {sources.map((source) => (
+                <a
+                  key={source.href}
+                  href={source.href}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="flex items-center gap-3 p-3 bg-white/80 dark:bg-gray-800/80 backdrop-blur-sm rounded-lg shadow hover:shadow-md transition-all border border-gray-200/50 dark:border-gray-700/50"
+                >
+                  <div className="flex-1">
+                    <div className="flex items-center gap-2">
+                      <span className="font-semibold text-gray-800 dark:text-gray-100">
+                        {source.label}
+                      </span>
+                      <span className="text-xs bg-blue-100 text-blue-700 dark:bg-blue-900/40 dark:text-blue-300 px-2 py-1 rounded">
+                        {source.tag}
+                      </span>
+                    </div>
+                  </div>
+                </a>
+              ))}
+            </div>
+          </div>
+        </div>
+      </div>
+    </section>
+    <AnimatePresence>
+      {activeTip !== null && (
+        <TipModal
+            title={language === "pl" ? tips[activeTip].pl : language === "no" ? tips[activeTip].no : tips[activeTip].en}
+            body={language === "pl" ? tips[activeTip].morePl : language === "no" ? tips[activeTip].moreNo : tips[activeTip].moreEn}
+            linkHref={tips[activeTip].link.href}
+            linkLabel={language === "pl" ? tips[activeTip].link.labelPl : language === "no" ? tips[activeTip].link.labelNo : tips[activeTip].link.labelEn}
+            onClose={() => setActiveTip(null)}
+          />
+      )}
+    </AnimatePresence>
+  </div>
+);
+}

TruthScan AI_frontend/app/saved/page.tsx

@@ -0,0 +1,15 @@
+/**
+ * Strona aplikacji prezentująca zapisane przez użytkownika artykuły.
+ *
+ * Stanowi prosty wrapper routingu Next.js dla komponentu SavedArticlesPage.
+ */
+
+"use client";
+
+import SavedArticlesPage from "../../components/SavedArticlesPage";
+
+export default function Page() {
+  return <SavedArticlesPage />;
+}
+
+

TruthScan AI_frontend/app/stores/newsCache.tsx

@@ -0,0 +1,90 @@
+/**
+ * Globalny cache danych newsowych po stronie frontendu.
+ * Implementuje prosty mechanizm TTL oraz synchronizację z localStorage.
+ */
+
+import { create } from "zustand";
+
+type CacheEntry<T = any> = {
+  data: T;
+  ts: number;           
+};
+
+type NewsCacheState = {
+  cache: Record<string, CacheEntry>;
+  ttlMs: number;
+  get: <T = any>(key: string) => T | null;
+  set: (key: string, data: any) => void;
+  del: (key: string) => void;
+  clear: () => void;
+};
+
+const TTL_5_MIN = 5 * 60 * 1000;
+
+const storageKey = "truthscan_news_cache_v1";
+
+// Odczyt cache z localStorage (jeśli dostępny)
+function loadFromStorage(): Record<string, CacheEntry> {
+  try {
+    const raw = localStorage.getItem(storageKey);
+    if (!raw) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+// Zapis cache do localStorage
+function saveToStorage(cache: Record<string, CacheEntry>) {
+  try {
+    localStorage.setItem(storageKey, JSON.stringify(cache));
+  } catch {
+    // ignorujemy błędy zapisu (np. quota exceeded)v
+  }
+}
+
+export const useNewsCache = create<NewsCacheState>((set, get) => ({
+  cache: typeof window !== "undefined" ? loadFromStorage() : {},
+  ttlMs: TTL_5_MIN,
+
+  get: <T = any>(key: string) => {
+    const { cache, ttlMs } = get();
+    const entry = cache[key];
+    if (!entry) return null;
+    const expired = Date.now() - entry.ts > ttlMs;
+    // Automatyczne wygaszanie wpisów cache (TTL)
+    if (expired) {
+      
+      const next = { ...cache };
+      delete next[key];
+      set({ cache: next });
+      saveToStorage(next);
+      return null;
+    }
+    return entry.data as T;
+  },
+
+  set: (key: string, data: any) => {
+    const { cache } = get();
+    const next = { ...cache, [key]: { data, ts: Date.now() } };
+    set({ cache: next });
+    saveToStorage(next);
+  },
+
+  del: (key: string) => {
+    const { cache } = get();
+    const next = { ...cache };
+    delete next[key];
+    set({ cache: next });
+    saveToStorage(next);
+  },
+
+  clear: () => {
+    set({ cache: {} });
+    saveToStorage({});
+  },
+}));
+
+// helper: klucz cache dla /news
+export const newsKey = (source: string, lang = "pl") => `news:${source}:${lang}`;
+// helper: klucz cache dla /emotion-stats
+export const statsKey = (source: string) => `stats:${source}`;

TruthScan AI_frontend/components/ArticleCard.tsx

@@ -0,0 +1,234 @@
+/**
+ * Komponent prezentujący pojedynczy artykuł informacyjny.
+ *
+ * Odpowiada za:
+ * - wyświetlanie metadanych artykułu (tytuł, źródło, data, sentyment),
+ * - obsługę akcji użytkownika (zapis, usunięcie, eksport do PDF),
+ * - integrację z hookami pomocniczymi (sentyment, favicona, treść artykułu),
+ * - renderowanie w trybie pełnym lub kompaktowym.
+ */
+
+"use client";
+
+import React, { useState } from "react";
+import { Article } from "../lib/fetchNews";
+import { useArticleContent } from "../app/hooks/useArticleContent";
+import { useFavicon } from "../app/hooks/useFavicon";
+import { useSentiment } from "../app/hooks/useSentiment";
+import PDFModal from "./PDFModal";
+import type { Lang } from "../lib/types";
+
+interface ArticleCardProps {
+  article: Article;
+  language: Lang;
+  locales: any;
+  onDelete?: (title: string) => void;
+  savedView?: boolean;
+  variant?: "full" | "compact";
+  onSave?: (article: Article) => void;
+}
+
+export default function ArticleCard({
+  article,
+  language,
+  locales,
+  onDelete,
+  savedView = false,
+  variant = "full",
+  onSave,
+}: ArticleCardProps) {
+  const { label: sentimentLabel, color: sentimentColor } = useSentiment(article.sentiment || "", language);
+  const { faviconSrc, sourceInitial, hasFavicon, nextFavicon } = useFavicon(article); 
+  const { fetchFullContent } = useArticleContent();
+  const [isExporting, setIsExporting] = useState(false);
+  const [isLoadingContent, setIsLoadingContent] = useState(false);
+  const [fullContent, setFullContent] = useState<string>("");
+  const [showPDF, setShowPDF] = useState(false);
+  const isCompact = variant === "compact";
+  const t = locales[language] ?? locales.pl;
+
+  const T = (pl: string, no: string, en: string) =>
+    language === "pl" ? pl : language === "no" ? no : en;
+
+  const handleExportPDF = async () => {
+    if (isExporting) return;
+    
+    setIsExporting(true);
+    try {
+      let contentToExport = article.summary || article.description || "";
+      
+      if (article.link && article.link.startsWith('http') && !fullContent) {
+        setIsLoadingContent(true);
+        try {
+          const fetchedContent = await fetchFullContent(article.link);
+          setFullContent(fetchedContent);
+        } catch (error) {
+          console.log("ℹ️ Używam dostępnej treści");
+        } finally {
+          setIsLoadingContent(false);
+        }
+      }
+
+      setShowPDF(true);
+    } catch (error) {
+      console.error("❌ Błąd przygotowania PDF:", error);
+      alert(T("Błąd podczas przygotowywania PDF", "Feil ved forberedelse av PDF", "Error preparing PDF"));
+    } finally {
+      setIsExporting(false);
+    }
+  };
+
+  const handlePDFClose = () => setShowPDF(false);
+  const handlePDFExportStart = () => console.log("🟡 Eksport PDF rozpoczęty");
+  const handlePDFExportEnd = () => {
+    console.log("🟢 Eksport PDF zakończony");
+    handlePDFClose();
+  };
+
+  const renderHeader = () => (
+    <div className="flex items-start gap-3 mb-2">
+      {hasFavicon ? ( 
+        <img
+          src={faviconSrc}
+          alt={`${article.source} favicon`}
+          width={24}
+          height={24}
+          className="w-6 h-6 rounded-sm mt-1 ring-1 ring-black/10 dark:ring-white/10 bg-white object-contain"
+          referrerPolicy="no-referrer"
+          onError={nextFavicon} 
+        />
+      ) : (
+        <div className="w-6 h-6 rounded-sm mt-1 bg-gray-200 dark:bg-gray-700 grid place-items-center text-xs font-semibold">
+          {sourceInitial}
+        </div>
+      )}
+
+      <h2 className={[
+        "font-bold text-blue-600 dark:text-blue-400",
+        isCompact ? "text-base leading-snug" : "text-lg"
+      ].join(" ")}>
+        {article.title}
+      </h2>
+    </div>
+  );
+
+  const renderDescription = () => (
+    <p className={[
+      "text-gray-700 dark:text-gray-300",
+      isCompact ? "text-sm line-clamp-3 mb-2" : "mb-3"
+    ].join(" ")}>
+      {article.summary || article.description ||
+        T("Brak opisu", "Ingen beskrivelse", "No description")}
+    </p>
+  );
+
+  const renderMetadata = () => (
+    <div className={[
+      "text-gray-500 dark:text-gray-400",
+      isCompact ? "text-xs space-y-0.5 mb-2" : "text-sm space-y-1 mb-3"
+    ].join(" ")}>
+      <p>
+        🕒 {T("Data", "Dato", "Date")}:{" "}
+        <time suppressHydrationWarning>
+          {article.published || T("Brak daty", "Ingen dato", "No date")}
+        </time>
+      </p>
+      <p>📰 {T("Źródło", "Kilde", "Source")}: {article.source || "-"}</p>
+      <p>
+        💬 {T("Sentyment", "Sentimentanalyse", "Sentiment")}:{" "}
+        <span className={sentimentColor}>{sentimentLabel}</span>
+      </p>
+      <p>
+        ❓ {T("Prawdopodobieństwo Fake News", "Sannsynlighet for falske nyheter", "Fake News Probability")}:{" "}
+        {typeof article.fake_probability === "number"
+          ? `${article.fake_probability.toFixed(2)}%`
+          : T("Brak danych", "Ingen data", "No data")}
+      </p>
+    </div>
+  );
+
+  const renderActions = () => (
+    <div className={[
+      "flex items-center gap-6 pt-2 border-t border-gray-300 dark:border-gray-700",
+      isCompact ? "mt-2" : "mt-3"
+    ].join(" ")}>
+      {article.link && (
+        <a
+          href={article.link.startsWith("http") ? article.link : `https://${article.link}`}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="text-blue-500 hover:text-blue-400 font-medium transition"
+        >
+          🔗 {T("Pokaż artykuł", "Vis artikkel", "View article")}
+        </a>
+      )}
+
+      {savedView && (
+        <button
+          onClick={handleExportPDF}
+          disabled={isExporting || isLoadingContent}
+          className={`text-purple-600 hover:text-purple-500 font-medium transition ${
+            (isExporting || isLoadingContent) ? 'opacity-50 cursor-not-allowed' : ''
+          }`}
+        >
+          {isLoadingContent ? '⏳' : isExporting ? '📄' : '📄'} 
+          {isLoadingContent
+            ? T(" Pobieranie...", " Laster inn...", " Loading...")
+            : T(" Eksportuj PDF", " Eksporter til PDF", " Export PDF")
+          }
+        </button>
+      )}
+
+      {savedView ? (
+        <button
+          onClick={() => {
+            if (confirm(T(
+              "Czy na pewno chcesz usunąć ten artykuł?",
+              "Er du sikker på at du vil slette denne artikkelen?",
+              "Are you sure you want to delete this article?"
+            ))) {
+              onDelete?.(article.title);
+            }
+          }}
+          className="text-red-500 hover:text-red-400 font-medium transition"
+        >
+          🗑️ {T("Usuń", "Slett", "Delete")}
+        </button>
+      ) : onSave ? (
+        <button
+          onClick={() => onSave(article)}
+          className="text-green-600 hover:text-green-500 font-medium transition"
+        >
+          💾 {T("Zapisz", "Lagre", "Save")}
+        </button>
+      ) : null}
+    </div>
+  );
+
+  return (
+    <>
+      <article className={[
+        "rounded-2xl border bg-white dark:bg-gray-800 border-gray-200 dark:border-gray-700 transition-all duration-300",
+        isCompact ? "p-4 shadow-sm hover:shadow-md" : "p-5 shadow-md hover:shadow-lg hover:-translate-y-0.5"
+      ].join(" ")}>
+        {renderHeader()}
+        {renderDescription()}
+        {renderMetadata()}
+        {renderActions()}
+      </article>
+
+      <PDFModal
+        article={article}
+        language={language}
+        sentimentLabel={sentimentLabel}
+        sentimentColor={sentimentColor}
+        fullContent={fullContent}
+        isLoadingContent={isLoadingContent}
+        showPDF={showPDF}
+        onClose={handlePDFClose}
+        onExportStart={handlePDFExportStart}
+        onExportEnd={handlePDFExportEnd}
+      />
+    </>
+  );
+}

TruthScan AI_frontend/components/ArticleList.tsx

@@ -0,0 +1,61 @@
+/**
+ * Komponent prezentujący pojedynczy artykuł informacyjny.
+ *
+ * Odpowiada za:
+ * - wyświetlanie metadanych artykułu (tytuł, źródło, data, sentyment),
+ * - obsługę akcji użytkownika (zapis, usunięcie, eksport do PDF),
+ * - integrację z hookami pomocniczymi (sentyment, favicona, treść artykułu),
+ * - renderowanie w trybie pełnym lub kompaktowym.
+ */
+
+"use client";
+
+import React from "react";
+import ArticleCard from "./ArticleCard";
+import locales from "../lib/locales";
+import { Article } from "../lib/fetchNews";
+import type { Lang } from "../lib/types";
+
+type ArticleListProps = {
+  articles: Article[];
+  language: Lang;
+  locales: typeof locales;
+  savedView?: boolean;
+  onDelete?: (title: string) => void; 
+};
+
+export default function ArticleList({
+  articles,
+  language,
+  locales,
+  savedView = false,
+  onDelete,
+}: ArticleListProps) {
+  if (!articles || articles.length === 0) {
+    return (
+      <p className="text-gray-500">
+        {language === "pl" ? "Brak artykułów do wyświetlenia." : language === "no" ? "Ingen artikler å vise." : "No articles to display."}
+      </p>
+    );
+  }
+
+  return (
+    <div className="space-y-4">
+      {articles.map((article, idx) => (
+        <ArticleCard
+          key={idx}
+          article={article}
+          language={language}
+          locales={locales}
+          savedView={savedView}
+          onDelete={onDelete ? () => onDelete(article.title) : undefined}
+        />
+      ))}
+    </div>
+  );
+}
+
+
+
+
+

TruthScan AI_frontend/components/DarkModeToggle.tsx

@@ -0,0 +1,53 @@
+/**
+ * Komponent przełącznika trybu jasnego i ciemnego (dark mode).
+ *
+ * Odpowiada za:
+ * - zarządzanie stanem trybu kolorystycznego interfejsu,
+ * - synchronizację ustawienia z localStorage,
+ * - dynamiczne dodawanie klasy `dark` do elementu <html>.
+ */
+
+"use client";
+
+import { useEffect, useState } from "react";
+import { Moon, Sun } from "lucide-react";
+
+export default function DarkModeToggle() {
+  const [darkMode, setDarkMode] = useState<boolean>(false);
+
+  useEffect(() => {
+    const saved = localStorage.getItem("darkMode");
+    if (saved === "true") {
+      setDarkMode(true);
+      document.documentElement.classList.add("dark");
+    }
+  }, []);
+
+  useEffect(() => {
+    if (darkMode) {
+      document.documentElement.classList.add("dark");
+    } else {
+      document.documentElement.classList.remove("dark");
+    }
+    localStorage.setItem("darkMode", String(darkMode));
+  }, [darkMode]);
+
+  return (
+    <button
+      onClick={() => setDarkMode(!darkMode)}
+      className="p-2 rounded-md bg-gray-200 dark:bg-gray-700 hover:bg-gray-300 dark:hover:bg-gray-600 transition-colors"
+      aria-label={darkMode ? "Przełącz na tryb jasny" : "Przełącz na tryb ciemny"}
+      title={darkMode ? "Tryb jasny" : "Tryb ciemny"}
+    >
+      {darkMode ? (
+        <Sun className="w-5 h-5 text-yellow-400" />
+      ) : (
+        <Moon className="w-5 h-5 text-gray-800 dark:text-white" />
+      )}
+    </button>
+  );
+}
+
+
+
+

TruthScan AI_frontend/components/EmotionalPieChart.tsx

@@ -0,0 +1,190 @@
+/**
+ * Komponent wizualizujący rozkład emocji w artykułach w formie wykresu kołowego.
+ *
+ * Odpowiada za:
+ * - normalizację i agregację danych sentymentu,
+ * - tłumaczenie etykiet w zależności od języka interfejsu,
+ * - prezentację danych z wykorzystaniem biblioteki Recharts,
+ * - obsługę tooltipów i etykiet procentowych.
+ */
+
+"use client";
+
+import { useMemo } from "react";
+import { PieChart, Pie, Cell, ResponsiveContainer, Tooltip, Legend } from "recharts";
+import { useLanguage } from "../app/hooks/useLanguage"; 
+import locales from "../lib/locales";
+
+interface EmotionalPieChartProps {
+  data: { name: string; value: number }[];
+  title?: string;
+}
+
+type Canonical = "POSITIVE" | "NEGATIVE" | "NEUTRAL";
+
+const EMOTION_COLORS = {
+  POSITIVE: "#22c55e", // green
+  NEGATIVE: "#ef4444", // red
+  NEUTRAL: "#3b82f6",  // blue
+} as const;
+
+const EMOTION_LABELS = {
+  pl: {
+    POSITIVE: "Pozytywne",
+    NEGATIVE: "Negatywne",
+    NEUTRAL:  "Neutralne",
+  },
+  en: {
+    POSITIVE: "Positive",
+    NEGATIVE: "Negative",
+    NEUTRAL:  "Neutral",
+  },
+  no: {
+    POSITIVE: "Positivt",
+    NEGATIVE: "Negativt",
+    NEUTRAL:  "Nøytralt",
+  },
+} as const;
+
+export default function EmotionalPieChart({ data, title }: EmotionalPieChartProps) {
+  const { language } = useLanguage();
+  const t = locales[language];
+
+  const toCanonical = (raw: string): Canonical | null => {
+    const u = (raw || "").trim().toUpperCase();
+    if (u === "POSITIVE" || u === "POZYTYWNE") return "POSITIVE";
+    if (u === "NEGATIVE" || u === "NEGATYWNE") return "NEGATIVE";
+    if (u === "NEUTRAL"  || u === "NEUTRALNE") return "NEUTRAL";
+    return null;
+  };
+
+  const translatedData = useMemo(() => {
+    const initialData: Record<Canonical, number> = {
+      POSITIVE: 0, NEGATIVE: 0, NEUTRAL: 0
+    };
+
+    for (const item of data) {
+      const c = toCanonical(item.name);
+      if (!c) continue;
+      initialData[c] = (initialData[c] ?? 0) + (item.value ?? 0);
+    }
+
+    return (["POSITIVE", "NEUTRAL", "NEGATIVE"] as Canonical[])
+      .map(canonical => ({
+        canonical,
+        name: EMOTION_LABELS[language][canonical],
+        value: initialData[canonical],
+        color: EMOTION_COLORS[canonical]
+      }))
+      .filter(item => item.value > 0);
+  }, [data, language]);
+
+  const totalValue = useMemo(() => 
+    translatedData.reduce((sum, item) => sum + item.value, 0), 
+    [translatedData]
+  );
+
+  const RAD = Math.PI / 180;
+
+  const renderLabel = ({ cx, cy, midAngle, outerRadius, name, value, payload }: any) => {
+    const r = (outerRadius ?? 0) + 14;
+    const x = cx + r * Math.cos(-midAngle * RAD);
+    const y = cy + r * Math.sin(-midAngle * RAD);
+    const anchor: "start" | "end" = x > cx ? "start" : "end";
+
+    const fill = EMOTION_COLORS[(payload?.canonical as Canonical) ?? "NEUTRAL"];
+    return (
+      <text x={x} y={y} fill={fill} textAnchor={anchor} dominantBaseline="central" 
+            className="text-[12px] select-none font-medium">
+        {`${name}: ${value}`}
+      </text>
+    );
+  };
+
+  const CustomTooltip = ({ active, payload }: any) => {
+    if (active && payload && payload.length) {
+      const data = payload[0].payload;
+      const percentage = totalValue > 0 ? (data.value / totalValue) * 100 : 0;
+      
+      return (
+        <div className="bg-gray-900 dark:bg-gray-800 p-3 rounded-lg border border-gray-700 shadow-lg">
+          <p className="text-white font-medium">{data.name}</p>
+          <p className="text-gray-300">
+            {language === "pl" ? "Liczba artykułów: " : language === "no" ? "Antall artikler: " : "Number of articles: "}
+            <span className="text-white font-semibold">{data.value}</span>
+          </p>
+          <p className="text-gray-300">
+            {language === "pl" ? "Procent: " : language === "no" ? "Prosent: " : "Percentage: "}
+            <span className="text-white font-semibold">{percentage.toFixed(1)}%</span>
+          </p>
+        </div>
+      );
+    }
+    return null;
+  };
+
+  if (translatedData.length === 0) {
+    return (
+      <div className="w-full">
+        <h3 className="text-m font-semibold mb-2 text-gray-800 dark:text-gray-100">
+          {title || t.emotionsInArticles}
+        </h3>
+        <div className="h-64 flex items-center justify-center border-2 border-dashed border-gray-300 dark:border-gray-600 rounded-lg">
+          <p className="text-gray-500 dark:text-gray-400 text-center">
+            {language === "pl" ? "Brak danych do wyświetlenia" : language === "no" ? "Ingen data å vise" : "No data to display"}
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="w-full">
+      <h3 className="text-m font-semibold mb-2 text-gray-800 dark:text-gray-100">
+        {title || t.emotionsInArticles}
+      </h3>
+
+      <div className="h-64">
+        <ResponsiveContainer width="100%" height="100%">
+          <PieChart margin={{ top: 8, right: 28, left: 28, bottom: 0 }}>
+            <Pie
+              data={translatedData}
+              dataKey="value"
+              nameKey="name"
+              cx="50%"
+              cy="50%"
+              outerRadius="70%"
+              label={renderLabel}
+              labelLine={false}
+              isAnimationActive={true}
+              animationDuration={500}
+            >
+              {translatedData.map((item, idx) => (
+                <Cell key={idx} fill={item.color} stroke="#1f2937" strokeWidth={1} />
+              ))}
+            </Pie>
+
+            <Tooltip content={<CustomTooltip />} />
+            
+            <Legend 
+              verticalAlign="bottom" 
+              height={36}
+              formatter={(value, entry: any) => (
+                <span style={{ color: entry.color, fontSize: '12px' }}>{value}</span>
+              )}
+              wrapperStyle={{ paddingTop: '10px' }}
+            />
+          </PieChart>
+        </ResponsiveContainer>
+      </div>
+
+      <p className="text-s text-center text-gray-500 dark:text-gray-400 mt-4">
+        {language === "pl"
+          ? "Wykres pokazuje rozkład emocji w analizowanych artykułach."
+          : language === "no"
+          ? "Diagrammet viser fordelingen av følelser i analyserte artikler."
+          : "This chart shows the distribution of detected emotions in articles."}
+      </p>
+    </div>
+  );
+}