fix: use parse_known_args and detect flake8/pylint via python -m

parse_cli_args now uses parse_known_args so unrecognized arguments
(Qt flags, etc.) pass through instead of hard-exiting. LinterRunner
detects flake8/pylint via python -m fallback when not in PATH.
Added 6 unit tests for CLI arg parsing and real flake8 verification.

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

Author: Lukas Geiger

PythonBox_v8.py

@@ -210,9 +210,10 @@ def parse_cli_args(argv: Optional[List[str]] = None) -> argparse.Namespace:
     parser.add_argument("-h", "--help", action="help", default=argparse.SUPPRESS,
                         help="Diese Hilfe anzeigen")
 
-    args = parser.parse_args(sys.argv[1:] if argv is None else argv)
+    args, remaining = parser.parse_known_args(sys.argv[1:] if argv is None else argv)
     if args.open is None and args.file:
         args.open = args.file
+    args._remaining = remaining
     return args
 
 
@@ -1237,6 +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
+        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
+            except Exception:
+                self._flake8_via_module = False
+        else:
+            self._flake8_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
+            except Exception:
+                self._pylint_via_module = False
+        else:
+            self._pylint_via_module = False
 
     def run_linter(self, code: str, file_path: Optional[str] = None) -> List[Dict]:
         """Führt Linter aus und gibt Ergebnisse zurück"""
@@ -1271,8 +1292,10 @@ def _run_flake8(self, file_path: str) -> List[Dict]:
         """Führt Flake8 aus"""
         results = []
         try:
+            cmd = ([sys.executable, "-m", "flake8"] if getattr(self, '_flake8_via_module', False)
+                   else ["flake8"])
             proc = subprocess.run(
-                ["flake8", "--format=%(row)d:%(col)d:%(code)s:%(text)s", file_path],
+                [*cmd, "--format=%(row)d:%(col)d:%(code)s:%(text)s", file_path],
                 capture_output=True, text=True, timeout=10
             )
 
@@ -1299,8 +1322,10 @@ def _run_pylint(self, file_path: str) -> List[Dict]:
         """Führt Pylint aus"""
         results = []
         try:
+            cmd = ([sys.executable, "-m", "pylint"] if getattr(self, '_pylint_via_module', False)
+                   else ["pylint"])
             proc = subprocess.run(
-                ["pylint", "--output-format=text", "--msg-template={line}:{column}:{msg_id}:{msg}",
+                [*cmd, "--output-format=text", "--msg-template={line}:{column}:{msg_id}:{msg}",
                  file_path],
                 capture_output=True, text=True, timeout=30
             )
@@ -4137,9 +4162,8 @@ def main(argv: Optional[List[str]] = None):
     if args.lint:
         sys.exit(run_lint_cli(args.lint))
 
-    cli_args = list(sys.argv[1:] if argv is None else argv)
     startup_file = args.open
-    app = QApplication([sys.argv[0], *cli_args])
+    app = QApplication([sys.argv[0]] + args._remaining)
     icon_path = Path(__file__).with_name("PythonBox.ico")
     icon = QIcon(str(icon_path)) if icon_path.exists() else QIcon()
     if not icon.isNull():

tests/test_cli_lint.py

@@ -7,6 +7,8 @@
 
 ROOT = Path(__file__).resolve().parents[1]
 SCRIPT = ROOT / "PythonBox_v8.py"
+sys.path.insert(0, str(ROOT))
+from PythonBox_v8 import parse_cli_args
 
 
 def run_lint(target: str, timeout: int = 30) -> subprocess.CompletedProcess:
@@ -80,5 +82,51 @@ def test_no_gui_started(self):
             os.unlink(path)
 
 
+class TestParseCLIArgs(unittest.TestCase):
+
+    def test_open_flag(self):
+        args = parse_cli_args(["--open", "test.py"])
+        self.assertEqual(args.open, "test.py")
+        self.assertIsNone(args.lint)
+
+    def test_lint_flag(self):
+        args = parse_cli_args(["--lint", "test.py"])
+        self.assertEqual(args.lint, "test.py")
+        self.assertIsNone(args.open)
+
+    def test_positional_file(self):
+        args = parse_cli_args(["test.py"])
+        self.assertEqual(args.open, "test.py")
+        self.assertIsNone(args.lint)
+
+    def test_no_args(self):
+        args = parse_cli_args([])
+        self.assertIsNone(args.open)
+        self.assertIsNone(args.lint)
+
+    def test_unknown_args_preserved(self):
+        args = parse_cli_args(["--open", "test.py", "-style", "fusion"])
+        self.assertEqual(args.open, "test.py")
+        self.assertIn("-style", args._remaining)
+
+    def test_lint_with_real_flake8(self):
+        with tempfile.NamedTemporaryFile(suffix=".py", mode="w",
+                                         encoding="utf-8", delete=False) as f:
+            f.write("import os\nimport os\n")
+            f.flush()
+            path = f.name
+        try:
+            result = run_lint(path)
+            if result.returncode == 1:
+                lines = result.stdout.strip().split("\n")
+                finding_lines = [l for l in lines if path in l]
+                self.assertTrue(len(finding_lines) > 0,
+                                "flake8 should find duplicate import")
+                for line in finding_lines:
+                    self.assertRegex(line, r".+:\d+:\d+: \S+ .+")
+        finally:
+            os.unlink(path)
+
+
 if __name__ == "__main__":
     unittest.main()