feat(project-view): Git-Status-Badges (M/S/U/D) neben Dateinamen

- status_for_path(): Qt-freie Hilfsfunktion mit Path.as_posix()-Normalisierung
  (löst Windows-Backslash vs. Porcelain-Forward-Slash korrekt auf)
- GitStatusDelegate: QStyledItemDelegate zeichnet farbige Badges rechts im Baum
- _load_git_status(): befüllt den Delegate-Cache bei set_root() und _refresh()
- 10 neue Regressionstests in tests/test_git_project_view_status.py
- Testsuite: 67 passed, 1 skipped (Baseline: 57/1)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: lukisch

CHANGELOG.md

@@ -5,6 +5,16 @@ Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.1.0/).
 
 ## [Unreleased]
 
+### Hinzugefügt
+
+- `features/project_view.py`: Git-Status-Indikatoren (M / S / SM / U / D / R) werden
+  jetzt rechts neben dem Dateinamen im Projektbaum angezeigt. Neue Hilfsfunktion
+  `status_for_path()` (Qt-frei, direkt testbar) sucht per `Path.as_posix()`-Normalisierung
+  auch auf Windows mit Backslash-Pfaden korrekt im Porcelain-Status-Dict. Neuer
+  `GitStatusDelegate` (`QStyledItemDelegate`) zeichnet farbige Badges; `_load_git_status()`
+  befüllt den Cache bei `set_root()` und `_refresh()`. 10 neue Regressionstests in
+  `tests/test_git_project_view_status.py`.
+
 ### Behoben
 
 - `features/remote_editor.py`: SSH/SFTP-Verbindungen laden bekannte Hostkeys und

features/project_view.py

@@ -5,16 +5,21 @@
 
 Zeigt eine Baumstruktur des geöffneten Projektordners an.
 Unterstützt Doppelklick zum Öffnen, Kontextmenü und Filter.
+Git-Status-Indikatoren (M/S/U/D) werden rechts neben dem Dateinamen eingeblendet.
 """
 
 from pathlib import Path
+from typing import Optional, Dict, TYPE_CHECKING
 from PySide6.QtWidgets import (
     QWidget, QVBoxLayout, QHBoxLayout, QTreeView, QFileSystemModel,
     QPushButton, QLabel, QLineEdit, QMenu, QFileDialog,
-    QMessageBox
+    QMessageBox, QStyledItemDelegate
 )
 from PySide6.QtCore import Qt, QDir, Signal, QSortFilterProxyModel, QModelIndex
-from PySide6.QtGui import QFont
+from PySide6.QtGui import QFont, QColor
+
+if TYPE_CHECKING:
+    from features.git_integration import GitFileStatus
 
 
 # Dateien/Ordner, die standardmäßig ausgeblendet werden
@@ -25,6 +30,89 @@
 }
 
 
+def status_for_path(
+    abs_path: str,
+    repo_root: str,
+    status_dict: Dict[str, "GitFileStatus"],
+) -> Optional["GitFileStatus"]:
+    """Sucht GitFileStatus für einen absoluten Dateipfad anhand eines Status-Dicts.
+
+    Normalisiert Windows-Backslashes zu Forward-Slashes (Porcelain-Format von
+    ``git status --porcelain``). Gibt None zurück, wenn der Pfad außerhalb des
+    Repos liegt oder kein Status-Eintrag existiert.
+
+    Args:
+        abs_path:    Absoluter Dateipfad (Windows- oder Unix-Trennzeichen).
+        repo_root:   Absoluter Pfad zum Repo-Wurzelordner.
+        status_dict: Dict aus ``GitRepo.get_status()`` (Keys: Slash-relativ).
+
+    Returns:
+        GitFileStatus oder None.
+    """
+    try:
+        rel = Path(abs_path).relative_to(repo_root)
+    except ValueError:
+        return None
+    return status_dict.get(rel.as_posix())
+
+
+class GitStatusDelegate(QStyledItemDelegate):
+    """Zeichnet einen farbigen Git-Status-Badge rechts neben dem Dateinamen.
+
+    Holt sich den absoluten Dateipfad über ``QFileSystemModel``/Proxy und
+    delegiert den Lookup an die Qt-freie ``status_for_path``-Funktion.
+    Ordner werden nicht beschriftet.
+    """
+
+    _BADGE_FONT_SIZE = 9
+
+    def __init__(self, fs_model: QFileSystemModel, proxy: QSortFilterProxyModel,
+                 parent=None):
+        super().__init__(parent)
+        self._fs_model = fs_model
+        self._proxy = proxy
+        self._status_dict: Dict[str, "GitFileStatus"] = {}
+        self._repo_root: str = ""
+
+    def set_status(self, repo_root: str, status_dict: Dict[str, "GitFileStatus"]):
+        """Setzt den aktuellen Git-Status-Cache (wird bei set_root/refresh aufgerufen)."""
+        self._repo_root = repo_root
+        self._status_dict = status_dict
+
+    def _status_for_index(self, index: QModelIndex) -> Optional["GitFileStatus"]:
+        source = self._proxy.mapToSource(index)
+        if not source.isValid():
+            return None
+        abs_path = self._fs_model.filePath(source)
+        if not abs_path or not self._repo_root:
+            return None
+        return status_for_path(abs_path, self._repo_root, self._status_dict)
+
+    def paint(self, painter, option, index):
+        super().paint(painter, option, index)
+        # Ordner nicht beschriften
+        source = self._proxy.mapToSource(index)
+        if source.isValid() and self._fs_model.isDir(source):
+            return
+        status = self._status_for_index(index)
+        if not (status and status.status_icon):
+            return
+        painter.save()
+        color = status.color_hint
+        if color:
+            painter.setPen(QColor(color))
+        badge_font = QFont("Consolas", self._BADGE_FONT_SIZE)
+        badge_font.setBold(True)
+        painter.setFont(badge_font)
+        rect = option.rect.adjusted(0, 0, -4, 0)
+        painter.drawText(
+            rect,
+            Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter,
+            status.status_icon,
+        )
+        painter.restore()
+
+
 class FileFilterProxy(QSortFilterProxyModel):
     """Filtert versteckte Dateien und Ordner."""
 
@@ -183,6 +271,10 @@ def _setup_ui(self):
         self.tree.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.tree.customContextMenuRequested.connect(self._on_context_menu)
 
+        # Git-Status-Delegate (zeigt M/S/U/D-Badges neben Dateinamen)
+        self.git_delegate = GitStatusDelegate(self.fs_model, self.proxy, self)
+        self.tree.setItemDelegateForColumn(0, self.git_delegate)
+
         layout.addWidget(self.tree)
 
     def set_root(self, path: str):
@@ -192,6 +284,7 @@ def set_root(self, path: str):
         proxy_root = self.proxy.mapFromSource(root_index)
         self.tree.setRootIndex(proxy_root)
         self._update_git_info()
+        self._load_git_status()
 
     def _update_git_info(self):
         """Aktualisiert die Git-Branch-Anzeige im Titel."""
@@ -206,13 +299,29 @@ def _update_git_info(self):
         else:
             self.title_label.setText(self._root_path.name)
 
+    def _load_git_status(self):
+        """Lädt den Git-Status aller geänderten Dateien für den aktuellen Root.
+
+        Befüllt den Cache des GitStatusDelegate, damit dieser beim Paint-Aufruf
+        sofort die Badges rendern kann.
+        """
+        if not self._root_path:
+            self.git_delegate.set_status("", {})
+            return
+        from features.git_integration import GitRepo
+        repo = GitRepo(str(self._root_path))
+        if repo.is_git_repo():
+            self.git_delegate.set_status(str(self._root_path), repo.get_status())
+        else:
+            self.git_delegate.set_status("", {})
+
     def _open_folder_dialog(self):
         path = QFileDialog.getExistingDirectory(self, "Projektordner wählen")
         if path:
             self.set_root(path)
 
     def _refresh(self):
-        """Aktualisiert die Ansicht."""
+        """Aktualisiert die Ansicht und den Git-Status-Cache."""
         if self._root_path:
             self.set_root(str(self._root_path))
 

tests/test_git_project_view_status.py

@@ -0,0 +1,101 @@
+"""Tests für status_for_path() in features/project_view.py.
+
+Prüft die Qt-freie Hilfsfunktion, die absoluten Dateipfaden einen
+GitFileStatus zuordnet — inkl. Windows-Pfad-Normalisierung.
+"""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from features.project_view import status_for_path
+from features.git_integration import GitFileStatus
+
+
+def _file_status(path: str, *, is_modified=False, is_untracked=False,
+                 is_staged=False, is_deleted=False) -> GitFileStatus:
+    """Baut ein minimales GitFileStatus für Tests."""
+    return GitFileStatus(
+        path=path,
+        index_status="M" if is_staged else ("D" if is_deleted else "?"),
+        work_status="M" if is_modified else ("D" if is_deleted else "?"),
+        is_staged=is_staged,
+        is_modified=is_modified,
+        is_untracked=is_untracked,
+        is_deleted=is_deleted,
+    )
+
+
+class TestStatusForPath(unittest.TestCase):
+
+    def test_simple_match_unix(self):
+        """Unix-Pfad: einfaches Match gegen Status-Key."""
+        sd = {"src/main.py": _file_status("src/main.py", is_modified=True)}
+        result = status_for_path("/repo/src/main.py", "/repo", sd)
+        self.assertIsNotNone(result)
+        self.assertTrue(result.is_modified)
+
+    def test_windows_backslash_normalization(self):
+        """Windows-Backslashes werden transparent zu Forward-Slashes normalisiert."""
+        sd = {"src/main.py": _file_status("src/main.py", is_modified=True)}
+        result = status_for_path(
+            r"C:\project\src\main.py", r"C:\project", sd
+        )
+        self.assertIsNotNone(result, "Windows-Pfad muss nach Normalisierung matchen")
+        self.assertTrue(result.is_modified)
+
+    def test_outside_repo_returns_none(self):
+        """Pfad außerhalb des Repo-Roots gibt None zurück (keine ValueError-Ausnahme)."""
+        sd = {"main.py": _file_status("main.py")}
+        result = status_for_path("/other/main.py", "/repo", sd)
+        self.assertIsNone(result)
+
+    def test_no_status_entry_returns_none(self):
+        """Saubere Datei ohne Status-Eintrag im Dict gibt None zurück."""
+        result = status_for_path("/repo/clean.py", "/repo", {})
+        self.assertIsNone(result)
+
+    def test_nested_path_untracked(self):
+        """Tief verschachtelte Pfade werden korrekt aufgelöst."""
+        sd = {"a/b/c/deep.py": _file_status("a/b/c/deep.py", is_untracked=True)}
+        result = status_for_path("/repo/a/b/c/deep.py", "/repo", sd)
+        self.assertIsNotNone(result)
+        self.assertTrue(result.is_untracked)
+
+    def test_staged_file_icon(self):
+        """Status-Icon einer rein gestageten Datei ist 'S'."""
+        sd = {"staged.py": _file_status("staged.py", is_staged=True)}
+        result = status_for_path("/repo/staged.py", "/repo", sd)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.status_icon, "S")
+
+    def test_deleted_file_icon(self):
+        """Status-Icon einer gelöschten Datei ist 'D'."""
+        sd = {"gone.py": _file_status("gone.py", is_deleted=True)}
+        result = status_for_path("/repo/gone.py", "/repo", sd)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.status_icon, "D")
+
+    def test_root_itself_returns_none(self):
+        """Der Repo-Root selbst taucht nicht im Status-Dict auf → None."""
+        result = status_for_path("/repo", "/repo", {})
+        self.assertIsNone(result)
+
+    def test_empty_status_dict_returns_none(self):
+        """Leeres Status-Dict: immer None."""
+        result = status_for_path("/repo/any.py", "/repo", {})
+        self.assertIsNone(result)
+
+    def test_windows_nested_backslash(self):
+        """Windows-Pfad mit mehreren Ebenen und Backslashes."""
+        sd = {"sub/dir/file.py": _file_status("sub/dir/file.py", is_modified=True)}
+        result = status_for_path(
+            r"C:\myproject\sub\dir\file.py", r"C:\myproject", sd
+        )
+        self.assertIsNotNone(result)
+        self.assertTrue(result.is_modified)
+
+
+if __name__ == "__main__":
+    unittest.main()