feat: add app version to about page

chore: bump yt-dlp to 2026.3.17

.github/workflows/build-release.yml

@@ -107,6 +107,12 @@ jobs:
           echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
           echo "version=${TAG#v}" >> "$GITHUB_OUTPUT"
 
+      - name: Write bundled version file
+        shell: bash
+        run: |
+          set -euo pipefail
+          printf '%s\n' "${{ steps.version.outputs.version }}" > version.txt
+
       - uses: actions/setup-python@v6
         with:
           python-version: "3.12"
@@ -124,14 +130,14 @@ jobs:
         run: |
           $ErrorActionPreference = "Stop"
           $ws = "${{ github.workspace }}"
-          pyinstaller --noconfirm --onefile --noconsole --name "ytpl-sync" --icon "$ws/assets/icon.ico" --add-data "$ws/assets/icon.png;assets" --distpath "dist/pyinstaller" --workpath "build/pyinstaller" --specpath "build/pyinstaller" --paths "src" "ytpl-sync-entry.py"
+          pyinstaller --noconfirm --onefile --noconsole --name "ytpl-sync" --icon "$ws/assets/icon.ico" --add-data "$ws/assets/icon.png;assets" --add-data "$ws/version.txt;." --distpath "dist/pyinstaller" --workpath "build/pyinstaller" --specpath "build/pyinstaller" --paths "src" "ytpl-sync-entry.py"
 
       - name: Build binary (Linux)
         if: runner.os == 'Linux'
         shell: bash
         run: |
           set -euo pipefail
-          pyinstaller --noconfirm --onefile --noconsole --name "ytpl-sync" --icon "${GITHUB_WORKSPACE}/assets/icon.png" --add-data "${GITHUB_WORKSPACE}/assets/icon.png:assets" --distpath "dist/pyinstaller" --workpath "build/pyinstaller" --specpath "build/pyinstaller" --paths "src" "ytpl-sync-entry.py"
+          pyinstaller --noconfirm --onefile --noconsole --name "ytpl-sync" --icon "${GITHUB_WORKSPACE}/assets/icon.png" --add-data "${GITHUB_WORKSPACE}/assets/icon.png:assets" --add-data "${GITHUB_WORKSPACE}/version.txt:." --distpath "dist/pyinstaller" --workpath "build/pyinstaller" --specpath "build/pyinstaller" --paths "src" "ytpl-sync-entry.py"
 
       - name: Stage package
         shell: bash

.github/workflows/update-yt-dlp.yml

@@ -0,0 +1,92 @@
+name: update yt-dlp
+on:
+  schedule:
+    - cron: "0 10 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+concurrency:
+  group: refresh-yt-dlp-pr
+  cancel-in-progress: true
+
+jobs:
+  refresh:
+    name: Update yt-dlp dependency
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Check and bump yt-dlp
+        id: detect
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          python - <<'PY' >> "$GITHUB_OUTPUT"
+          from __future__ import annotations
+
+          import json
+          import re
+          from pathlib import Path
+          from urllib.request import urlopen
+
+          def version_tuple(text: str) -> tuple[int, ...]:
+              parts = re.findall(r"\d+", text)
+              return tuple(int(p) for p in parts)
+
+          pyproject = Path("pyproject.toml")
+          text = pyproject.read_text(encoding="utf-8")
+
+          dep_match = re.search(r'^\s*"yt-dlp>=(?P<version>[^"]+)"\s*,?\s*$', text, re.MULTILINE)
+          if not dep_match:
+              raise SystemExit("Could not find yt-dlp dependency in pyproject.toml")
+
+          dep_version = dep_match.group("version")
+
+          latest_payload = urlopen("https://pypi.org/pypi/yt-dlp/json", timeout=30)
+          latest_version = json.load(latest_payload)["info"]["version"]
+
+          needs_update = version_tuple(latest_version) > version_tuple(dep_version)
+
+          print(f"needs_update={'true' if needs_update else 'false'}")
+          print(f"latest_yt_dlp={latest_version}")
+          print(f"current_yt_dlp={dep_version}")
+
+          if needs_update:
+              text = re.sub(
+                  r'(^\s*"yt-dlp>=)[^"]+(")',
+                  rf'\g<1>{latest_version}\2',
+                  text,
+                  flags=re.MULTILINE,
+              )
+              pyproject.write_text(text, encoding="utf-8")
+          PY
+
+      - name: Create or update pull request
+        if: steps.detect.outputs.needs_update == 'true'
+        uses: peter-evans/create-pull-request@v8
+        with:
+          branch: chore/refresh-yt-dlp
+          commit-message: "chore: bump yt-dlp to ${{ steps.detect.outputs.latest_yt_dlp }}"
+          title: "chore: bump yt-dlp to ${{ steps.detect.outputs.latest_yt_dlp }}"
+          body: |
+            Automated yt-dlp dependency refresh.
+
+            - Current version: `${{ steps.detect.outputs.current_yt_dlp }}`
+            - Latest version: `${{ steps.detect.outputs.latest_yt_dlp }}`
+          labels: deps
+          delete-branch: false
+          add-paths: |
+            pyproject.toml

.gitignore

@@ -8,6 +8,7 @@ config/yt-playlist-config.json
 *.code-workspace
 /bin/*
 /db/*
+plans
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

plans/python_youtube_playlist_sync_conversion_plan.md

@@ -1,8 +1,5 @@
 # YouTube Playlist Sync — Project Conversion Plan
 
-Repository:
-
-- [darkzoul5/YoutubePlaylistDownloader](https://github.com/darkzoul5/YoutubePlaylistDownloader?utm_source=chatgpt.com)
 
 ---
 

pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ytpl-sync"
-version = "1.1.1"
-description = "YouTube playlist Sync Thing"
+version = "2.1.1"
+description = "YouTube playlist Sync"
 readme = "README.md"
 authors = [ { name = "Dark_Zoul" } ]
 license = { file = "LICENSE" }
@@ -23,7 +23,7 @@ test = [
 ]
 
 [project.urls]
-Home = "https://github.com/darkzoul5/YoutubePlaylistSyncThing"
+Home = "https://github.com/darkzoul5/YoutubePlaylistSync"
 
 [project.scripts]
 ytpl-sync = "app.cli:main"

src/app/core/database/db.py

@@ -33,6 +33,13 @@ CREATE TABLE IF NOT EXISTS playlist_items (
 
 
 class Database:
+    """Thin SQLite persistence layer for playlists and playlist items.
+
+    The database stores the local synchronization state so the sync pipeline
+    can compare remote playlist data with what has already been downloaded,
+    renamed, or marked as removed.
+    """
+
     def __init__(self, db_path: Path) -> None:
         self.path = db_path
         self.path.parent.mkdir(parents=True, exist_ok=True)
@@ -41,10 +48,12 @@ class Database:
         self._migrate()
 
     def _migrate(self) -> None:
+        """Create the schema if this database has not been initialized yet."""
         with self._conn:
             self._conn.executescript(SCHEMA)
 
     def upsert_playlist_items(self, rows: Iterable[tuple]):
+        """Insert or refresh the cached metadata for playlist entries."""
         sql = (
             "INSERT INTO playlist_items (playlist_id, video_id, title, playlist_index, local_filename, downloaded, last_seen) "
             "VALUES (?, ?, ?, ?, ?, ?, datetime('now')) "
@@ -56,6 +65,7 @@ class Database:
             self._conn.executemany(sql, rows)
 
     def get_items_index(self, playlist_id: str) -> dict[str, sqlite3.Row]:
+        """Return all cached items for a playlist keyed by video id."""
         cur = self._conn.execute(
             "SELECT * FROM playlist_items WHERE playlist_id = ?",
             (playlist_id,),
@@ -63,6 +73,7 @@ class Database:
         return {row["video_id"]: row for row in cur.fetchall()}
 
     def upsert_playlist(self, *, id: str, name: str | None, url: str, path: str, mode: str, auto_sync: int = 0, sync_interval_minutes: int = 0) -> None:
+        """Insert or update the playlist configuration row."""
         sql = (
             "INSERT INTO playlists (id, name, url, path, mode, auto_sync, sync_interval_minutes, last_sync) "
             "VALUES (?, ?, ?, ?, ?, ?, ?, NULL) "
@@ -73,6 +84,7 @@ class Database:
             self._conn.execute(sql, (id, name, url, path, mode, auto_sync, sync_interval_minutes))
 
     def update_local_filename(self, playlist_id: str, video_id: str, local_filename: str | None) -> None:
+        """Record the current filename associated with a playlist item."""
         with self._conn:
             self._conn.execute(
                 "UPDATE playlist_items SET local_filename = ?, last_seen = datetime('now') WHERE playlist_id = ? AND video_id = ?",
@@ -80,6 +92,7 @@ class Database:
             )
 
     def mark_downloaded(self, playlist_id: str, video_id: str, downloaded: bool) -> None:
+        """Mark whether a playlist item is present on disk."""
         with self._conn:
             self._conn.execute(
                 "UPDATE playlist_items SET downloaded = ?, last_seen = datetime('now') WHERE playlist_id = ? AND video_id = ?",
@@ -87,6 +100,7 @@ class Database:
             )
 
     def clear_file_state(self, playlist_id: str, video_id: str) -> None:
+        """Clear filename and downloaded flags after a deletion or recycle."""
         with self._conn:
             self._conn.execute(
                 "UPDATE playlist_items SET local_filename = NULL, downloaded = 0, last_seen = datetime('now') WHERE playlist_id = ? AND video_id = ?",
@@ -94,6 +108,7 @@ class Database:
             )
 
     def set_playlist_last_sync(self, playlist_id: str) -> None:
+        """Store the timestamp of the most recent successful sync."""
         with self._conn:
             self._conn.execute(
                 "UPDATE playlists SET last_sync = datetime('now') WHERE id = ?",
@@ -101,6 +116,7 @@ class Database:
             )
 
     def get_playlist_last_sync(self, playlist_id: str) -> str | None:
+        """Return the last sync timestamp for a playlist, if any."""
         cur = self._conn.execute("SELECT last_sync FROM playlists WHERE id = ?", (playlist_id,))
         row = cur.fetchone()
         if not row:

src/app/core/download/queue_manager.py

@@ -37,6 +37,13 @@ class DownloadJob:
 
 
 class QueueManager:
+    """A small asyncio worker pool for download jobs.
+
+    Jobs are pushed into a shared queue and processed by a fixed number of
+    background tasks. This keeps the downloader concurrency bounded without
+    forcing the caller to manage worker lifetimes directly.
+    """
+
     def __init__(self, concurrency: int = 2) -> None:
         self._queue: "asyncio.Queue[DownloadJob]" = asyncio.Queue()
         self._concurrency = max(1, concurrency)
@@ -44,6 +51,7 @@ class QueueManager:
         self._stopped = asyncio.Event()
 
     async def start(self, worker_coro):
+        """Start the worker tasks that drain the queue."""
         async def runner(idx: int):
             while not self._stopped.is_set():
                 job = await self._queue.get()
@@ -55,13 +63,16 @@ class QueueManager:
         self._workers = [asyncio.create_task(runner(i)) for i in range(self._concurrency)]
 
     async def stop(self):
+        """Cancel all worker tasks and mark the queue as stopped."""
         self._stopped.set()
         for w in self._workers:
             w.cancel()
         self._workers.clear()
 
     async def enqueue(self, job: DownloadJob):
+        """Add a job to the shared queue."""
         await self._queue.put(job)
 
     async def join(self) -> None:
+        """Block until every queued job has been acknowledged."""
         await self._queue.join()

src/app/core/scanner/playlist_scanner.py

@@ -8,16 +8,19 @@ from ..models import PlaylistItem
 
 class PlaylistScanner:
     """
-    Fetches remote playlist entries using yt-dlp (no downloads).
+    Fetches remote playlist entries using yt-dlp without downloading media.
 
-    This class intentionally avoids strict dependencies at import time. If
-    yt_dlp is unavailable, call sites should handle the raised ImportError.
+    The scanner is deliberately lightweight: it extracts remote metadata only
+    and leaves persistence, diffing, and download decisions to higher layers.
+    Import-time dependency checks are avoided so the rest of the application can
+    still start in environments where yt-dlp is unavailable.
     """
 
     def __init__(self) -> None:
         pass
 
     def scan(self, playlist_url: str, playlist_id: str, *, ffmpeg_path: Optional[str] = None) -> List[PlaylistItem]:
+        """Return the current remote playlist entries as `PlaylistItem` records."""
         try:
             import yt_dlp  # type: ignore
         except Exception as exc:  # pragma: no cover - environment dependent

src/app/core/sync/executor.py

@@ -18,12 +18,25 @@ from ..utils.rate_limit import is_youtube_rate_limit_error
 
 
 class ActionExecutor:
+    """Apply sync actions against the filesystem and persist their outcome.
+
+    The executor is the imperative half of the sync pipeline: it publishes
+    lifecycle events, performs safe renames and deletions, coordinates the
+    download queue, and updates the database after each job completes.
+    """
+
     def __init__(self, db: Database, concurrency: int = 2, event_bus: EventBus | None = None) -> None:
         self.concurrency = max(1, concurrency)
         self.db = db
         self.bus = event_bus
 
     async def execute(self, actions: Iterable[SyncAction], playlist_cfg: dict, *, cancel_check=None, pause_check=None) -> None:
+        """Execute a batch of sync actions for one playlist.
+
+        The workflow is intentionally ordered: announce the sync, wait for any
+        pause state to clear, validate dependencies, perform renames, recycle
+        deletions, and finally run downloads with bounded concurrency.
+        """
         actions_list = list(actions)
         playlist_id = extract_playlist_id(playlist_cfg.get("url", "")) or playlist_cfg.get("url", "")
         start = time.monotonic()
@@ -123,6 +136,7 @@ class ActionExecutor:
             ensure_ffmpeg_available(str(ffmpeg_hint) if ffmpeg_hint is not None else None)
 
     async def _apply_renames(self, actions: Iterable[SyncAction], audio_root: Path, video_root: Path, playlist_cfg: dict) -> None:
+        """Apply all rename actions in batches separated by output type."""
         playlist_id = extract_playlist_id(playlist_cfg.get("url", "")) or playlist_cfg.get("url", "")
         audio_renames = []
         video_renames = []
@@ -152,6 +166,7 @@ class ActionExecutor:
                     await self.bus.publish("RenameApplied", {"playlist_id": playlist_id, "video_id": a.item.video_id, "to": a.to_name})
 
     def _apply_deletions(self, actions: Iterable[SyncAction], audio_root: Path, video_root: Path, playlist_cfg: dict) -> None:
+        """Recycle or remove files that no longer belong to the playlist."""
         playlist_id = extract_playlist_id(playlist_cfg.get("url", "")) or playlist_cfg.get("url", "")
         recycle_audio = audio_root.parent / ".recycle" / "audio"
         recycle_video = video_root.parent / ".recycle" / "video"
@@ -198,6 +213,7 @@ class ActionExecutor:
         cancel_check=None,
         pause_check=None,
     ) -> None:
+        """Queue and run download jobs, then persist their final state."""
         playlist_id = extract_playlist_id(playlist_cfg.get("url", "")) or playlist_cfg.get("url", "")
         loop = asyncio.get_running_loop()
         concurrency_cfg = playlist_cfg.get("max_parallel_downloads", self.concurrency)

src/app/core/sync/service.py

@@ -13,6 +13,13 @@ from ..utils.yt import extract_playlist_id
 
 
 class SyncService:
+    """High-level orchestration for a single playlist sync pass.
+
+    The service pulls the latest remote playlist snapshot, persists the
+    playlist and item metadata in the database, and asks the diff engine to
+    compare the remote state with the local filesystem.
+    """
+
     def __init__(self, db: Database) -> None:
         self.db = db
         self.scanner = PlaylistScanner()
@@ -28,6 +35,12 @@ class SyncService:
         return [".mp4"]
 
     def sync_from_config(self, playlist_cfg: dict) -> List[SyncAction]:
+        """Return the sync actions required to bring one playlist in sync.
+
+        This method does not apply any changes itself. It normalizes the
+        configuration, refreshes the playlist/item records in SQLite, and then
+        computes the actions needed for the configured download mode.
+        """
         url: str = playlist_cfg.get("url")
         mode: str = playlist_cfg.get("download_mode", "video")
         save_path = Path(playlist_cfg.get("save_path", "./downloads")).resolve()

src/app/core/utils/version.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def _resource_base() -> Path:
+    # PyInstaller sets sys._MEIPASS to the temp extraction dir.
+    base = getattr(sys, "_MEIPASS", None)
+    if base:
+        return Path(str(base))
+    return Path.cwd()
+
+
+def _read_text(path: Path) -> str | None:
+    try:
+        if path.exists():
+            text = path.read_text(encoding="utf-8").strip()
+            return text or None
+    except Exception:
+        pass
+    return None
+def get_app_version() -> str:
+    """
+    Returns the packaged app version.
+
+    In release builds this reads from `version.txt` bundled into the EXE.
+    """
+    candidates = [
+        Path("version.txt"),
+        _resource_base() / "version.txt",
+    ]
+    for candidate in candidates:
+        text = _read_text(candidate)
+        if text:
+            return text
+
+    return "dev"

src/app/gui/main.py

@@ -15,6 +15,7 @@ from .pages.playlists import PlaylistManagerPage
 from .pages.queue import QueuePage
 from .pages.logs import LogsPage
 from .pages.settings import SettingsPage
+from .pages.about import AboutPage
 
 
 class MainWindow(QtWidgets.QMainWindow):
@@ -38,29 +39,37 @@ class MainWindow(QtWidgets.QMainWindow):
         # Sidebar navigation
         self._nav = QtWidgets.QListWidget()
         self._nav.setObjectName("sidebar")
-        self._nav.setFixedWidth(220)
         self._nav.setSpacing(2)
+        self._nav.setHorizontalScrollBarPolicy(
+            QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff
+        )
+        self._nav.setVerticalScrollBarPolicy(
+            QtCore.Qt.ScrollBarPolicy.ScrollBarAsNeeded
+        )
         self._nav.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.SingleSelection)
+        self._nav.model().rowsInserted.connect(self._update_sidebar_width)
+        self._nav.model().dataChanged.connect(self._update_sidebar_width)
+        self._nav.model().rowsRemoved.connect(self._update_sidebar_width)
 
         self._stack = QtWidgets.QStackedWidget()
         self._playlists_page = PlaylistManagerPage(self._settings)
         self._queue_page = QueuePage()
         self._logs_page = LogsPage()
         self._settings_page = SettingsPage()
+        self._about_page = AboutPage()
 
         self._pages: list[QtWidgets.QWidget] = [
             self._playlists_page,
             self._queue_page,
             self._logs_page,
             self._settings_page,
+            self._about_page,
         ]
         for p in self._pages:
             self._stack.addWidget(p)
 
-        for label in ("Playlists", "Queue", "Logs", "Settings"):
-            item = QtWidgets.QListWidgetItem(label)
-            item.setSizeHint(QtCore.QSize(200, 36))
-            self._nav.addItem(item)
+        for label in ("Playlists", "Queue", "Logs", "Settings", "About"):
+            self._add_sidebar_item(label)
 
         self._nav.currentRowChanged.connect(self._stack.setCurrentIndex)
         self._nav.setCurrentRow(0)
@@ -93,6 +102,29 @@ class MainWindow(QtWidgets.QMainWindow):
 
         self._refresh_queue_labels()
         self._init_tray()
+        QtCore.QTimer.singleShot(0, self._update_sidebar_width)
+
+    def _add_sidebar_item(self, label: str) -> None:
+        item = QtWidgets.QListWidgetItem(label)
+        self._nav.addItem(item)
+        self._update_sidebar_width()
+
+    def _update_sidebar_width(self, *_args: object) -> None:
+        metrics = self._nav.fontMetrics()
+        max_text_width = 0
+        for row in range(self._nav.count()):
+            item = self._nav.item(row)
+            if item is None:
+                continue
+            max_text_width = max(max_text_width, metrics.horizontalAdvance(item.text()))
+
+        if max_text_width <= 0:
+            return
+
+        frame = self._nav.frameWidth() * 2
+        padding = 44
+        target_width = max_text_width + frame + padding
+        self._nav.setFixedWidth(max(120, min(220, target_width)))
 
     def _tray_config(self) -> dict:
         # Read from disk so toggles apply immediately (no restart required).
@@ -325,8 +357,11 @@ class MainWindow(QtWidgets.QMainWindow):
         self.setStyleSheet(
             """
             QMainWindow { background: #0f1115; color: #e6e6e6; }
-            QWidget { font-size: 13px; }
+            QWidget { font-size: 13px; color: #e6e6e6; }
             QLabel#pageTitle { font-size: 18px; font-weight: 600; padding: 4px 0; }
+            QLabel[muted="true"] { color: #aeb6c2; }
+            QLabel[link="true"] { color: #8fb8ff; }
+            QLabel[link="true"]:hover { color: #b8d2ff; }
 
             QListWidget#sidebar {
               background: #0b0d11;
@@ -348,6 +383,30 @@ class MainWindow(QtWidgets.QMainWindow):
               gridline-color: #20242d;
               border: 1px solid #20242d;
             }
+            QGroupBox {
+              border: 1px solid #20242d;
+              border-radius: 10px;
+              margin-top: 14px;
+              padding: 12px;
+              background: #0b0d11;
+            }
+            QGroupBox::title {
+              subcontrol-origin: margin;
+              left: 12px;
+              padding: 0 6px;
+              color: #d5dae3;
+              background: #0b0d11;
+            }
+            QFrame#aboutCard {
+              background: #0b0d11;
+              border: 1px solid #20242d;
+              border-radius: 14px;
+            }
+            QLabel#cardTitle {
+              font-size: 15px;
+              font-weight: 600;
+              color: #f2f4f8;
+            }
             QHeaderView::section {
               background: #0b0d11;
               color: #cfd3da;

src/app/gui/pages/about.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from PySide6 import QtCore, QtGui, QtWidgets
+
+from ...core.utils.version import get_app_version
+
+
+class AboutPage(QtWidgets.QWidget):
+    def __init__(self, parent: QtWidgets.QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setObjectName("aboutPage")
+
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.setContentsMargins(16, 16, 16, 16)
+        layout.setSpacing(14)
+
+        title = QtWidgets.QLabel("About")
+        title.setObjectName("pageTitle")
+        layout.addWidget(title)
+
+        layout.addWidget(self._hero_card())
+        layout.addWidget(self._project_card())
+        layout.addWidget(self._suggestions_card())
+        layout.addStretch(1)
+
+    def _card(self) -> tuple[QtWidgets.QFrame, QtWidgets.QVBoxLayout]:
+        card = QtWidgets.QFrame()
+        card.setObjectName("aboutCard")
+
+        card_layout = QtWidgets.QVBoxLayout(card)
+        card_layout.setContentsMargins(16, 16, 16, 16)
+        card_layout.setSpacing(10)
+        return card, card_layout
+
+    def _card_title(self, text: str) -> QtWidgets.QLabel:
+        label = QtWidgets.QLabel(text)
+        label.setObjectName("cardTitle")
+        return label
+
+    def _muted_label(self, text: str) -> QtWidgets.QLabel:
+        label = QtWidgets.QLabel(text)
+        label.setWordWrap(True)
+        label.setProperty("muted", True)
+        return label
+
+    def _link_button(self, text: str, url: str) -> QtWidgets.QPushButton:
+        button = QtWidgets.QPushButton(text)
+        button.setCursor(QtCore.Qt.CursorShape.PointingHandCursor)
+        button.clicked.connect(
+            lambda: QtGui.QDesktopServices.openUrl(QtCore.QUrl(url))
+        )
+        return button
+
+    def _hero_card(self) -> QtWidgets.QFrame:
+        card, layout = self._card()
+        layout.addWidget(self._card_title("About this project"))
+        layout.addWidget(
+            self._muted_label(
+                "ytpl-sync is a desktop app for keeping local copies of YouTube playlists in sync."
+            )
+        )
+        layout.addWidget(
+            self._muted_label(
+                "This is a student project."
+            )
+        )
+        return card
+
+    def _project_card(self) -> QtWidgets.QFrame:
+        card, layout = self._card()
+        layout.addWidget(self._card_title("Project"))
+
+        form = QtWidgets.QFormLayout()
+        form.setLabelAlignment(QtCore.Qt.AlignmentFlag.AlignLeft)
+        form.setFormAlignment(
+            QtCore.Qt.AlignmentFlag.AlignTop | QtCore.Qt.AlignmentFlag.AlignLeft
+        )
+        form.setHorizontalSpacing(14)
+        form.setVerticalSpacing(10)
+
+        author = self._muted_label("Dark_Zoul")
+        form.addRow("Author", author)
+
+        version_text = get_app_version()
+        version = self._muted_label(f"v{version_text}" if version_text != "unknown" else version_text)
+        form.addRow("Version", version)
+
+        repo_row = QtWidgets.QHBoxLayout()
+        repo_row.setContentsMargins(0, 0, 0, 0)
+        repo_row.setSpacing(10)
+        repo_row.addWidget(
+            self._link_button(
+                "Open",
+                "https://github.com/darkzoul5/YoutubePlaylistSync",
+            )
+        )
+        repo_row.addStretch(1)
+        form.addRow("Repository", repo_row)
+
+        issue_row = QtWidgets.QHBoxLayout()
+        issue_row.setContentsMargins(0, 0, 0, 0)
+        issue_row.setSpacing(10)
+        issue_row.addWidget(
+            self._link_button(
+                "Open",
+                "https://github.com/darkzoul5/YoutubePlaylistSync/issues",
+            )
+        )
+        issue_row.addStretch(1)
+        form.addRow("Issues", issue_row)
+
+        layout.addLayout(form)
+        return card
+
+    def _suggestions_card(self) -> QtWidgets.QFrame:
+        card, layout = self._card()
+        layout.addWidget(self._card_title("Suggestions"))
+
+        suggestions = [
+            "Keep the app updated regularly so that YouTube extraction stays reliable."
+        ]
+        for text in suggestions:
+            layout.addWidget(self._muted_label(f"• {text}"))
+
+        layout.addStretch(1)
+        return card