fix: gate linter module detection on returncode == 0

subprocess.run does not raise on non-zero exit, so python -m flake8
on a system without flake8 exits 1 silently, wrongly setting
has_flake8 = True and making the AST fallback unreachable.
Now checks proc.returncode before setting the flag. Added 3 unit
tests with mocked subprocess to verify detection logic.

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

Author: Lukas Geiger

PythonBox_v8.py

@@ -1238,26 +1238,26 @@ def _check_available_linters(self):
         """Prüft welche Linter verfügbar sind"""
         self.has_pylint = shutil.which("pylint") is not None
         self.has_flake8 = shutil.which("flake8") is not None
+        self._flake8_via_module = False
         if not self.has_flake8:
             try:
-                subprocess.run([sys.executable, "-m", "flake8", "--version"],
-                               capture_output=True, timeout=5)
-                self.has_flake8 = True
-                self._flake8_via_module = True
+                proc = subprocess.run([sys.executable, "-m", "flake8", "--version"],
+                                      capture_output=True, timeout=5)
+                if proc.returncode == 0:
+                    self.has_flake8 = True
+                    self._flake8_via_module = True
             except Exception:
-                self._flake8_via_module = False
-        else:
-            self._flake8_via_module = False
+                pass
+        self._pylint_via_module = False
         if not self.has_pylint:
             try:
-                subprocess.run([sys.executable, "-m", "pylint", "--version"],
-                               capture_output=True, timeout=5)
-                self.has_pylint = True
-                self._pylint_via_module = True
+                proc = subprocess.run([sys.executable, "-m", "pylint", "--version"],
+                                      capture_output=True, timeout=5)
+                if proc.returncode == 0:
+                    self.has_pylint = True
+                    self._pylint_via_module = True
             except Exception:
-                self._pylint_via_module = False
-        else:
-            self._pylint_via_module = False
+                pass
 
     def run_linter(self, code: str, file_path: Optional[str] = None) -> List[Dict]:
         """Führt Linter aus und gibt Ergebnisse zurück"""

tests/test_cli_lint.py

@@ -4,11 +4,12 @@
 import tempfile
 import unittest
 from pathlib import Path
+from unittest.mock import patch, MagicMock
 
 ROOT = Path(__file__).resolve().parents[1]
 SCRIPT = ROOT / "PythonBox_v8.py"
 sys.path.insert(0, str(ROOT))
-from PythonBox_v8 import parse_cli_args
+from PythonBox_v8 import parse_cli_args, LinterRunner
 
 
 def run_lint(target: str, timeout: int = 30) -> subprocess.CompletedProcess:
@@ -128,5 +129,47 @@ def test_lint_with_real_flake8(self):
             os.unlink(path)
 
 
+class TestLinterDetection(unittest.TestCase):
+
+    @patch("shutil.which", return_value=None)
+    @patch("subprocess.run")
+    def test_missing_flake8_not_detected(self, mock_run, mock_which):
+        mock_result = MagicMock()
+        mock_result.returncode = 1
+        mock_run.return_value = mock_result
+        runner = LinterRunner.__new__(LinterRunner)
+        runner.has_flake8 = False
+        runner.has_pylint = False
+        runner._check_available_linters()
+        self.assertFalse(runner.has_flake8)
+        self.assertFalse(getattr(runner, '_flake8_via_module', False))
+
+    @patch("shutil.which", return_value=None)
+    @patch("subprocess.run")
+    def test_missing_pylint_not_detected(self, mock_run, mock_which):
+        mock_result = MagicMock()
+        mock_result.returncode = 1
+        mock_run.return_value = mock_result
+        runner = LinterRunner.__new__(LinterRunner)
+        runner.has_flake8 = False
+        runner.has_pylint = False
+        runner._check_available_linters()
+        self.assertFalse(runner.has_pylint)
+        self.assertFalse(getattr(runner, '_pylint_via_module', False))
+
+    @patch("shutil.which", return_value=None)
+    @patch("subprocess.run")
+    def test_module_flake8_detected_on_success(self, mock_run, mock_which):
+        mock_result = MagicMock()
+        mock_result.returncode = 0
+        mock_run.return_value = mock_result
+        runner = LinterRunner.__new__(LinterRunner)
+        runner.has_flake8 = False
+        runner.has_pylint = False
+        runner._check_available_linters()
+        self.assertTrue(runner.has_flake8)
+        self.assertTrue(runner._flake8_via_module)
+
+
 if __name__ == "__main__":
     unittest.main()