Refactor dependency analysis and packaging plugin

- Added a method to resolve the Python interpreter for virtual environments in `analyser.py`.
- Enhanced the logic to exclude virtual environment directories from analysis.
- Updated the dependency checking mechanism to utilize the active interpreter from the Venv Manager.
- Removed the entire Packaging plugin and its associated language files, as it is no longer needed.
- Introduced a new modern theme for the UI with a comprehensive stylesheet for better aesthetics.

Author: PyCompiler ARK++

Core/Venv_Manager/Manager.py

@@ -6,6 +6,7 @@
 import platform
 import shutil
 import sys
+import re
 
 from PySide6.QtCore import QProcess, QTimer
 from PySide6.QtWidgets import QApplication, QFileDialog, QMessageBox
@@ -20,6 +21,9 @@ class VenvManager:
     Responsibilities:
     - Manual venv selection (updates parent UI label and internal path)
     - Create venv if missing
+    - Discover multiple venvs and select the best suited for the workspace
+    - Ensure/generate project requirements automatically if missing
+    - Provide interpreter and pip command to other components (central authority)
     - Check/install tools in an existing venv
     - Install project requirements.txt
     - Report/terminate active background tasks related to venv operations
@@ -62,29 +66,283 @@ def __init__(self, parent_widget):
         # Internal timers to enforce timeouts on background processes
         self._proc_timers: list[QTimer] = []
 
-    # ---------- Public helpers for engines ----------
+        # Centralized active workspace/venv state
+        self.workspace_dir: str | None = None
+        self.active_venv: dict | None = None  # {'path': str, 'python': str, 'score': float, 'distance': int}
+        self._project_requirements_path: str | None = None
+
+    # ---------- Public helpers for engines and analyzers ----------
+    def set_selected_workspace(self, workspace_dir: str):
+        """Set the active workspace, ensure requirements, discover/select venv, and cache interpreter/pip."""
+        try:
+            self.workspace_dir = os.path.abspath(workspace_dir) if workspace_dir else None
+            if not self.workspace_dir or not os.path.isdir(self.workspace_dir):
+                self._safe_log("❌ Workspace invalide pour VenvManager.")
+                return
+            # Ensure requirements file exists
+            self._project_requirements_path = self.ensure_project_requirements(self.workspace_dir)
+            # Discover venvs
+            venvs = self.discover_venvs(self.workspace_dir)
+            # Select best venv (may be None)
+            reqs = self.get_project_requirements(self.workspace_dir)
+            best = self.select_best_venv(self.workspace_dir, venvs, reqs)
+            self.active_venv = best
+            if best and best.get('python'):
+                self._safe_log(f"ℹ️ Venv sélectionné: {best.get('path')} (score={best.get('score', 0):.2f}, distance={best.get('distance', 0)})")
+            else:
+                self._safe_log("ℹ️ Aucun venv approprié trouvé. Les opérations pip utiliseront l'interpréteur courant.")
+        except Exception as e:
+            self._safe_log(f"⚠️ set_selected_workspace: {e}")
+
     def resolve_project_venv(self) -> str | None:
-        """Resolve the venv root to use based on manual selection or workspace.
-        Prefers an existing .venv over venv; if none exists, returns the default path (.venv).
-        """
+        """Resolve the venv root to use based on manual selection or discovered best venv."""
         try:
             manual = getattr(self.parent, "venv_path_manuel", None)
             if manual:
-                base = os.path.abspath(manual)
-                return base
-            if getattr(self.parent, "workspace_dir", None):
-                base = os.path.abspath(self.parent.workspace_dir)
-                existing, default_path = self._detect_venv_in(base)
+                return os.path.abspath(manual)
+            if self.active_venv and self.active_venv.get('path'):
+                return self.active_venv['path']
+            if self.workspace_dir:
+                existing, default_path = self._detect_venv_in(self.workspace_dir)
                 return existing or default_path
         except Exception:
             return None
         return None
 
+    def get_active_interpreter(self) -> str | None:
+        """Return the python interpreter path of the selected venv, if any."""
+        try:
+            root = self.resolve_project_venv()
+            if root:
+                return self.python_path(root)
+        except Exception:
+            pass
+        return None
+
+    def get_pip_command(self) -> tuple[str, list[str]]:
+        """Return (program, prefix_args) for invoking pip as python -m pip in the active venv (or current python)."""
+        prog = self.get_active_interpreter() or sys.executable
+        return prog, ["-m", "pip"]
+
     def pip_path(self, venv_root: str) -> str:
         return os.path.join(
             venv_root, "Scripts" if platform.system() == "Windows" else "bin", "pip"
         )
 
+    # ---------- Discovery/select best venv ----------
+    def discover_venvs(self, workspace_dir: str, max_depth: int = 3) -> list[dict]:
+        """Scan workspace for venv-like folders and return list of dicts with path, python, distance."""
+        results: list[dict] = []
+        try:
+            ws = os.path.abspath(workspace_dir)
+            candidates = {"venv", ".venv", "env", ".env", "ev", ".ev"}
+            for root, dirs, files in os.walk(ws):
+                # compute depth relative to ws
+                rel = os.path.relpath(root, ws)
+                depth = 0 if rel == '.' else len(rel.split(os.sep))
+                if depth > max_depth:
+                    # prune deeper levels
+                    dirs[:] = []
+                    continue
+                # if this folder itself is a venv root candidate name
+                base = os.path.basename(root)
+                if base in candidates:
+                    py = self.python_path(root)
+                    if os.path.isfile(py) and os.path.isfile(os.path.join(root, 'pyvenv.cfg')):
+                        results.append({
+                            'path': root,
+                            'python': py,
+                            'distance': depth,
+                        })
+                    # do not dive into venv internals further
+                    dirs[:] = []
+                    continue
+                # Also prune typical venv internals for performance
+                if base in (".git", "__pycache__", "node_modules"):
+                    dirs[:] = []
+                    continue
+        except Exception as e:
+            self._safe_log(f"⚠️ discover_venvs: {e}")
+        # Manual venv takes precedence if set
+        manual = getattr(self.parent, "venv_path_manuel", None)
+        if manual:
+            mpath = os.path.abspath(manual)
+            py = self.python_path(mpath)
+            if os.path.isfile(py):
+                return [{'path': mpath, 'python': py, 'distance': 0}] + [v for v in results if v['path'] != mpath]
+        return results
+
+    def get_project_requirements(self, workspace_dir: str) -> set[str]:
+        """Return a normalized set of requirement package names for the project.
+        Looks for requirements.txt/constraints.txt/pyproject.toml; if none and a cached path exists, use it."""
+        reqs: set[str] = set()
+        try:
+            ws = os.path.abspath(workspace_dir)
+            # requirements.txt
+            req_path = os.path.join(ws, "requirements.txt")
+            if os.path.isfile(req_path):
+                with open(req_path, encoding="utf-8", errors="ignore") as f:
+                    for line in f:
+                        line = line.strip()
+                        if not line or line.startswith('#'):
+                            continue
+                        # strip version specifiers
+                        pkg = re.split(r"[<>=!~]", line, 1)[0].strip()
+                        if pkg:
+                            reqs.add(pkg)
+                return reqs
+            # constraints.txt
+            c_path = os.path.join(ws, "constraints.txt")
+            if os.path.isfile(c_path):
+                with open(c_path, encoding="utf-8", errors="ignore") as f:
+                    for line in f:
+                        line = line.strip()
+                        if not line or line.startswith('#'):
+                            continue
+                        pkg = re.split(r"[<>=!~]", line, 1)[0].strip()
+                        if pkg:
+                            reqs.add(pkg)
+                return reqs
+            # pyproject.toml (basic read without tomli dependency)
+            pp = os.path.join(ws, "pyproject.toml")
+            if os.path.isfile(pp):
+                try:
+                    import tomllib  # py311+
+                except Exception:
+                    tomllib = None
+                if tomllib:
+                    try:
+                        with open(pp, 'rb') as f:
+                            data = tomllib.load(f)
+                        deps = data.get('project', {}).get('dependencies', []) or []
+                        for d in deps:
+                            pkg = re.split(r"[<>=!~]", d, 1)[0].strip()
+                            if pkg:
+                                reqs.add(pkg)
+                        return reqs
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+        return reqs
+
+    def ensure_project_requirements(self, workspace_dir: str) -> str | None:
+        """Ensure the project has a requirements.txt; if missing, generate it via dependency analysis."""
+        try:
+            ws = os.path.abspath(workspace_dir)
+            req_path = os.path.join(ws, "requirements.txt")
+            if os.path.isfile(req_path):
+                return req_path
+            # Try to generate: basic import scan from Python files in workspace
+            pkgs = self._analyze_workspace_imports(ws)
+            if pkgs:
+                with open(req_path, 'w', encoding='utf-8') as f:
+                    for p in sorted(pkgs):
+                        f.write(p + "\n")
+                self._safe_log(f"📝 requirements.txt généré ({len(pkgs)} packages).")
+                return req_path
+            return None
+        except Exception as e:
+            self._safe_log(f"⚠️ ensure_project_requirements: {e}")
+            return None
+
+    def select_best_venv(self, workspace_dir: str, venvs: list[dict], requirements: set[str]) -> dict | None:
+        """Select the best venv based on distance to root and how many deps are already satisfied."""
+        if not venvs:
+            return None
+        try:
+            # Precompute installed pkgs once per venv using 'pip list --format=json'
+            enriched = []
+            for v in venvs:
+                installed = self._pip_list_names(v['python'])
+                if installed is None:
+                    score = 0.0
+                else:
+                    have = sum(1 for r in requirements if r.lower() in installed)
+                    total = len(requirements) or 1
+                    score = have / total
+                v2 = dict(v)
+                v2['score'] = score
+                enriched.append(v2)
+            # Choose: minimal distance, then maximal score
+            enriched.sort(key=lambda x: (x.get('distance', 0), -x.get('score', 0.0)))
+            return enriched[0]
+        except Exception as e:
+            self._safe_log(f"⚠️ select_best_venv: {e}")
+            return venvs[0]
+
+    # ---------- Internal helpers ----------
+    def _pip_list_names(self, python_exe: str) -> set[str] | None:
+        try:
+            import subprocess, json
+            cp = subprocess.run([
+                python_exe, '-m', 'pip', 'list', '--format', 'json'
+            ], capture_output=True, text=True)
+            if cp.returncode != 0:
+                return None
+            data = json.loads(cp.stdout.strip() or '[]')
+            names = { (item.get('name') or '').lower() for item in data if item.get('name') }
+            return names
+        except Exception:
+            return None
+
+    def _analyze_workspace_imports(self, workspace_dir: str) -> set[str]:
+        """Very lightweight import analyzer to extract top-level packages from .py files, excluding stdlib and venv dirs."""
+        pkgs: set[str] = set()
+        try:
+            import ast, sysconfig, pkgutil, re as _re
+            ws = os.path.abspath(workspace_dir)
+            # Exclude common venv dirs
+            exclude_dirs = {".venv", "venv", "env", ".env", "ev", ".ev", "__pycache__", ".git"}
+            for root, dirs, files in os.walk(ws):
+                base = os.path.basename(root)
+                if base in exclude_dirs:
+                    dirs[:] = []
+                    continue
+                # prune venv internals
+                for d in list(dirs):
+                    if d in exclude_dirs:
+                        dirs.remove(d)
+                for fn in files:
+                    if not fn.endswith('.py'):
+                        continue
+                    fpath = os.path.join(root, fn)
+                    try:
+                        with open(fpath, encoding='utf-8') as f:
+                            src = f.read()
+                        tree = ast.parse(src, filename=fpath)
+                        for node in ast.walk(tree):
+                            if isinstance(node, ast.Import):
+                                for alias in node.names:
+                                    pkgs.add(alias.name.split('.') [0])
+                            elif isinstance(node, ast.ImportFrom):
+                                if node.module:
+                                    pkgs.add(node.module.split('.') [0])
+                        # dynamic imports
+                        dyn = _re.findall(r"__import__\(['\"]([\w\.]+)['\"]\)", src)
+                        pkgs.update([m.split('.')[0] for m in dyn])
+                        mod = _re.findall(r"importlib\.import_module\(['\"]([\w\.]+)['\"]\)", src)
+                        pkgs.update([m.split('.')[0] for m in mod])
+                    except Exception:
+                        continue
+            # remove stdlib and common internals
+            std = set(sys.builtin_module_names)
+            try:
+                import sysconfig as _sc
+                stdlib_path = _sc.get_path('stdlib') or ''
+                stdlib_path = os.path.realpath(stdlib_path)
+                # best effort: also add stdlib discovered modules
+                for _, name, _ in pkgutil.iter_modules([stdlib_path]):
+                    std.add(name)
+            except Exception:
+                pass
+            # Heuristic removal of common internals
+            core_names = {"Core", "ENGINES", "Plugins", "engine_sdk", "Plugins_SDK"}
+            out = {m for m in pkgs if m not in std and m not in core_names}
+            return out
+        except Exception:
+            return set()
+
     def python_path(self, venv_root: str) -> str:
         base = os.path.join(
             venv_root, "Scripts" if platform.system() == "Windows" else "bin"