feat(plugin): add dependency checking for plugin loading

Author: sun

src/compileo/features/plugin/__pycache__/manager.cpython-312.pyc

@@ -344,16 +344,21 @@ def _load_single_plugin(self, plugin_dir: Path):
             with open(manifest_path, 'r') as f:
                 manifest_data = yaml.safe_load(f)
             manifest = PluginManifest(**manifest_data)
-            
+
+            # Check dependencies before loading
+            if not self._check_dependencies(plugin_dir):
+                logger.warning(f"Skipping plugin {manifest.id}: dependencies not installed")
+                return
+
             # Add plugin src to sys.path so it can import its own modules
             # We add the root of the plugin directory
             if str(plugin_dir) not in sys.path:
                 sys.path.insert(0, str(plugin_dir))
-            
+
             # Dynamic Import
             entry_path_dir = plugin_dir / manifest.entry_point.replace(".", "/") / "__init__.py"
             entry_path_file = plugin_dir / f"{manifest.entry_point.replace('.', '/')}.py"
-            
+
             spec = None
             if entry_path_dir.exists():
                 spec = importlib.util.spec_from_file_location(
@@ -365,15 +370,15 @@ def _load_single_plugin(self, plugin_dir: Path):
                     f"plugins.{manifest.id}",
                     entry_path_file
                 )
-            
+
             if spec and spec.loader:
                 module = importlib.util.module_from_spec(spec)
                 sys.modules[f"plugins.{manifest.id}"] = module
                 spec.loader.exec_module(module)
-                
+
                 self.loaded_plugins[manifest.id] = module
                 self.plugin_manifests[manifest.id] = manifest
-                
+
                 # Register Extensions
                 self._register_extensions(manifest, module)
                 logger.info(f"Loaded plugin: {manifest.name} ({manifest.version})")
@@ -390,14 +395,50 @@ def _register_extensions(self, manifest: PluginManifest, module: Any):
         for ext_point, items in manifest.extensions.items():
             if ext_point not in self.extensions:
                 self.extensions[ext_point] = {}
-            
+
             for key, class_name in items.items():
                 if hasattr(module, class_name):
                     cls = getattr(module, class_name)
                     self.extensions[ext_point][key] = cls
                 else:
                     logger.warning(f"Plugin {manifest.id} declares {class_name} for {ext_point}, but class not found in module.")
 
+    def _check_dependencies(self, plugin_dir: Path) -> bool:
+        """
+        Checks if the plugin's dependencies are installed by attempting to import key packages.
+        """
+        requirements_path = plugin_dir / "requirements.txt"
+        if not requirements_path.exists():
+            return True  # No requirements file, assume dependencies are satisfied
+
+        try:
+            with open(requirements_path, 'r') as f:
+                requirements = f.read().splitlines()
+
+            # Extract package names (before any version specifiers)
+            packages_to_check = []
+            for req in requirements:
+                req = req.strip()
+                if req and not req.startswith('#'):
+                    # Extract package name (e.g., 'scrapy==2.11.1' -> 'scrapy')
+                    package_name = req.split('==')[0].split('>=')[0].split('>')[0].split('<')[0].split('<=')[0].split('!=')[0].strip()
+                    if package_name:
+                        packages_to_check.append(package_name)
+
+            # Try to import each package
+            for package in packages_to_check:
+                try:
+                    importlib.import_module(package)
+                except ImportError:
+                    logger.debug(f"Dependency check failed for {package} in plugin {plugin_dir.name}")
+                    return False
+
+            return True
+
+        except Exception as e:
+            logger.warning(f"Error checking dependencies for plugin {plugin_dir.name}: {e}")
+            return False
+
     def get_extensions(self, extension_point: str) -> Dict[str, Any]:
         """
         Returns a dictionary of {key: ImplementationClass} for a given extension point.