domd 2.2.7__tar.gz → 2.2.8__tar.gz

{domd-2.2.7 → domd-2.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: domd
-Version: 2.2.7
+Version: 2.2.8
 Summary: Project Command Detector - Automatically detects and tests project commands, generates TODO.md for failed commands
 License: Apache-2.0
 Author: Tom Sapletta

{domd-2.2.7 → domd-2.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "domd"
-version = "2.2.7"
+version = "2.2.8"
 description = "Project Command Detector - Automatically detects and tests project commands, generates TODO.md for failed commands"
 authors = ["Tom Sapletta <info@softreck.dev>"]
 maintainers = ["WRONAI Team"]

domd-2.2.8/src/domd/core/command_detection/handlers/command_handler.py

@@ -0,0 +1,207 @@
+"""Handler for executing and managing project commands."""
+
+import logging
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from ...services.command_runner import CommandRunner
+from ..models import Command, CommandResult
+
+logger = logging.getLogger(__name__)
+
+
+class CommandHandler:
+    """Handler for executing and managing project commands."""
+
+    def __init__(
+        self,
+        project_path: Path,
+        command_runner: CommandRunner,
+        timeout: int = 60,
+        ignore_patterns: Optional[List[str]] = None,
+    ):
+        """Initialize the CommandHandler.
+
+        Args:
+            project_path: Path to the project root
+            command_runner: CommandRunner instance for executing commands
+            timeout: Default command execution timeout in seconds
+            ignore_patterns: List of command patterns to ignore
+        """
+        self.project_path = project_path
+        self.command_runner = command_runner
+        self.timeout = timeout
+        self.ignore_patterns = ignore_patterns or []
+
+        # Command storage - can contain both Command objects and dictionaries
+        self.failed_commands: List[Union[Command, Dict[str, Any]]] = []
+        self.successful_commands: List[Union[Command, Dict[str, Any]]] = []
+        self.ignored_commands: List[Union[Command, Dict[str, Any]]] = []
+
+    def test_commands(self, commands: List[Union[Command, Dict]]) -> None:
+        """Test a list of commands and update internal state.
+
+        Args:
+            commands: List of Command objects or command dictionaries to test
+        """
+        self.failed_commands = []
+        self.successful_commands = []
+        self.ignored_commands = []
+
+        for cmd in commands:
+            try:
+                # Handle both Command objects and dictionaries
+                if self.should_ignore_command(cmd):
+                    self._handle_ignored_command(cmd)
+                    continue
+
+                # Execute the command
+                result = self.execute_single_command(cmd)
+
+                # Update command state based on result
+                if result.get("success"):
+                    self._handle_successful_command(cmd, result)
+                else:
+                    self._handle_failed_command(cmd, result)
+
+            except Exception as e:
+                logger.error(f"Error testing command: {e}", exc_info=True)
+                self._handle_error(cmd, str(e))
+
+    def execute_single_command(self, cmd_info: Union[Command, Dict]) -> Dict[str, Any]:
+        """Execute a single command and return the result.
+
+        Args:
+            cmd_info: Either a Command object or a dictionary containing command info
+
+        Returns:
+            Dictionary with command execution results
+        """
+        if isinstance(cmd_info, Command):
+            command = cmd_info.command
+            cwd = cmd_info.metadata.get("cwd", self.project_path)
+            env = cmd_info.metadata.get("env", {})
+            timeout = cmd_info.metadata.get("timeout", self.timeout)
+        else:
+            command = cmd_info.get("command", "")
+            cwd = cmd_info.get("cwd", self.project_path)
+            env = cmd_info.get("env", {})
+            timeout = cmd_info.get("timeout", self.timeout)
+
+        try:
+            start_time = time.time()
+            result = self.command_runner.run(
+                command=command,
+                cwd=cwd,
+                env=env,
+                timeout=timeout,
+            )
+            execution_time = time.time() - start_time
+
+            return {
+                "success": result.return_code == 0,
+                "return_code": result.return_code,
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "execution_time": execution_time,
+            }
+        except Exception as e:
+            logger.error(f"Error executing command '{command}': {e}", exc_info=True)
+            return {
+                "success": False,
+                "return_code": -1,
+                "error": str(e),
+                "stdout": "",
+                "stderr": str(e),
+                "execution_time": 0,
+            }
+
+    def should_ignore_command(self, command: Union[str, Dict, Command]) -> bool:
+        """Check if a command should be ignored based on ignore patterns.
+
+        Args:
+            command: Command to check (string, dict, or Command object)
+
+        Returns:
+            True if the command should be ignored, False otherwise
+        """
+        if not self.ignore_patterns:
+            return False
+
+        cmd_str = self._extract_command_string(command)
+        if not cmd_str:
+            return False
+
+        return any(pattern in cmd_str for pattern in self.ignore_patterns)
+
+    def _extract_command_string(self, command: Union[str, Dict, Command]) -> str:
+        """Extract the command string from various input types."""
+        if isinstance(command, str):
+            return command
+        if isinstance(command, dict):
+            return command.get("command", "")
+        if hasattr(command, "command"):
+            return command.command
+        return str(command)
+
+    def _handle_ignored_command(self, command: Union[Command, Dict]) -> None:
+        """Handle a command that should be ignored."""
+        if isinstance(command, dict):
+            command["ignored"] = True
+        else:
+            setattr(command, "ignored", True)
+        self.ignored_commands.append(command)
+        logger.debug(f"Ignored command: {self._extract_command_string(command)}")
+
+    def _handle_successful_command(
+        self, command: Union[Command, Dict], result: Dict[str, Any]
+    ) -> None:
+        """Handle a successfully executed command."""
+        self._update_command_result(command, result, success=True)
+        self.successful_commands.append(command)
+        logger.debug(f"Command succeeded: {self._extract_command_string(command)}")
+
+    def _handle_failed_command(
+        self, command: Union[Command, Dict], result: Dict[str, Any]
+    ) -> None:
+        """Handle a failed command execution."""
+        self._update_command_result(command, result, success=False)
+        self.failed_commands.append(command)
+        logger.warning(f"Command failed: {self._extract_command_string(command)}")
+
+    def _handle_error(self, command: Union[Command, Dict], error: str) -> None:
+        """Handle an error during command execution."""
+        result = {
+            "success": False,
+            "error": error,
+            "return_code": -1,
+            "stdout": "",
+            "stderr": error,
+        }
+        self._update_command_result(command, result, success=False)
+        self.failed_commands.append(command)
+        logger.error(f"Error executing command: {error}")
+
+    def _update_command_result(
+        self, command: Union[Command, Dict], result: Dict[str, Any], success: bool
+    ) -> None:
+        """Update a command object with execution results."""
+        if isinstance(command, dict):
+            command.update(
+                {
+                    "success": success,
+                    "return_code": result.get("return_code", -1),
+                    "stdout": result.get("stdout", ""),
+                    "stderr": result.get("stderr", ""),
+                    "error": result.get("error"),
+                    "execution_time": result.get("execution_time", 0),
+                }
+            )
+        else:
+            command.success = success
+            command.return_code = result.get("return_code", -1)
+            command.stdout = result.get("stdout", "")
+            command.stderr = result.get("stderr", "")
+            command.error = result.get("error")
+            command.execution_time = result.get("execution_time", 0)

domd-2.2.8/src/domd/core/command_detection/handlers/config_handler.py

@@ -0,0 +1,131 @@
+"""Handler for finding and processing configuration files."""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Union
+
+from ...services.file_processor import FileProcessor
+from ...services.pattern_matcher import PatternMatcher
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigFileHandler:
+    """Handler for finding and processing configuration files."""
+
+    def __init__(
+        self,
+        project_path: Path,
+        exclude_patterns: Optional[List[str]] = None,
+        include_patterns: Optional[List[str]] = None,
+        ignore_file: Optional[Path] = None,
+    ):
+        """Initialize the ConfigFileHandler.
+
+        Args:
+            project_path: Path to the project root
+            exclude_patterns: List of file patterns to exclude
+            include_patterns: List of file patterns to include
+            ignore_file: Path to the ignore file
+        """
+        self.project_path = project_path
+        self.exclude_patterns = set(exclude_patterns or [])
+        self.include_patterns = set(include_patterns or [])
+        self.ignore_file = ignore_file
+        self.file_processor = FileProcessor(project_root=project_path)
+        self.pattern_matcher = PatternMatcher()
+
+        # Load ignore patterns from file if provided
+        if self.ignore_file and self.ignore_file.exists():
+            self._load_ignore_patterns()
+
+    def find_config_files(self, parsers: List[Any]) -> List[Path]:
+        """Find all configuration files that can be parsed by the given parsers.
+
+        Args:
+            parsers: List of parser instances that can parse configuration files
+
+        Returns:
+            List of Path objects to configuration files
+        """
+        if not parsers:
+            logger.warning("No parsers provided, cannot find config files")
+            return []
+
+        # Get all supported file patterns from parsers
+        supported_patterns: Set[str] = set()
+        for parser in parsers:
+            if hasattr(parser, "get_supported_files"):
+                patterns = parser.get_supported_files()
+                if patterns:
+                    supported_patterns.update(patterns)
+
+        if not supported_patterns:
+            logger.warning("No supported file patterns found in parsers")
+            return []
+
+        logger.debug(f"Looking for files matching patterns: {supported_patterns}")
+
+        # Find all files matching the patterns
+        matched_files = self.file_processor.find_files(
+            patterns=supported_patterns,
+            exclude_patterns=self.exclude_patterns,
+            include_patterns=self.include_patterns,
+            max_depth=3,  # Limit depth for performance
+        )
+
+        logger.info(f"Found {len(matched_files)} configuration files")
+        return matched_files
+
+    def _load_ignore_patterns(self) -> None:
+        """Load ignore patterns from the ignore file."""
+        if not self.ignore_file or not self.ignore_file.exists():
+            return
+
+        try:
+            with open(self.ignore_file, "r", encoding="utf-8") as f:
+                patterns = [
+                    line.strip()
+                    for line in f
+                    if line.strip() and not line.startswith("#")
+                ]
+                self.exclude_patterns.update(patterns)
+                logger.info(
+                    f"Loaded {len(patterns)} ignore patterns from {self.ignore_file}"
+                )
+        except Exception as e:
+            logger.error(f"Error loading ignore patterns from {self.ignore_file}: {e}")
+
+    def should_process_file(self, file_path: Union[str, Path]) -> bool:
+        """Check if a file should be processed based on include/exclude patterns.
+
+        Args:
+            file_path: Path to the file to check
+
+        Returns:
+            True if the file should be processed, False otherwise
+        """
+        if not isinstance(file_path, Path):
+            file_path = Path(file_path)
+
+        if not file_path.exists() or not file_path.is_file():
+            return False
+
+        # Convert to relative path for pattern matching
+        try:
+            rel_path = file_path.relative_to(self.project_path)
+        except ValueError:
+            # File is outside project directory
+            return False
+
+        # Check exclude patterns first
+        if self.pattern_matcher.match_any_pattern(str(rel_path), self.exclude_patterns):
+            return False
+
+        # If include patterns are specified, file must match at least one
+        if self.include_patterns and not self.pattern_matcher.match_any_pattern(
+            str(rel_path), self.include_patterns
+        ):
+            return False
+
+        return True

domd-2.2.8/src/domd/core/command_detection/parsers/__init__.py

@@ -0,0 +1,6 @@
+"""Parsers for detecting commands in various file types."""
+
+from .base_parser import BaseParser
+from .parser_registry import ParserRegistry
+
+__all__ = ["ParserRegistry", "BaseParser"]

domd-2.2.8/src/domd/core/command_detection/parsers/base_parser.py

@@ -0,0 +1,85 @@
+"""Base parser class for detecting commands in configuration files."""
+
+import abc
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Union
+
+from ...models import Command
+
+logger = logging.getLogger(__name__)
+
+
+class BaseParser(abc.ABC):
+    """Abstract base class for command parsers."""
+
+    @classmethod
+    @abc.abstractmethod
+    def get_supported_files(cls) -> Set[str]:
+        """Get the file patterns this parser can handle.
+        
+        Returns:
+            Set of file patterns (e.g., {"*.py", "*.sh"})
+        """
+        raise NotImplementedError("Subclasses must implement get_supported_files()")
+    
+    @abc.abstractmethod
+    def parse(self, content: str, file_path: Optional[Path] = None) -> List[Command]:
+        """Parse commands from file content.
+        
+        Args:
+            content: File content to parse
+            file_path: Optional path to the file being parsed
+            
+        Returns:
+            List of Command objects
+        """
+        raise NotImplementedError("Subclasses must implement parse()")
+    
+    def parse_file(self, file_path: Union[str, Path]) -> List[Command]:
+        """Parse commands from a file.
+        
+        Args:
+            file_path: Path to the file to parse
+            
+        Returns:
+            List of Command objects
+        """
+        file_path = Path(file_path)
+        if not file_path.exists():
+            logger.warning(f"File not found: {file_path}")
+            return []
+            
+        try:
+            content = file_path.read_text(encoding="utf-8")
+            return self.parse(content, file_path=file_path)
+        except Exception as e:
+            logger.error(f"Error parsing file {file_path}: {e}", exc_info=True)
+            return []
+    
+    def can_parse(self, file_path: Union[str, Path]) -> bool:
+        """Check if this parser can handle the given file.
+        
+        Args:
+            file_path: Path to the file to check
+            
+        Returns:
+            True if this parser can handle the file, False otherwise
+        """
+        file_path = Path(file_path)
+        supported_patterns = self.get_supported_files()
+        
+        # If no patterns are specified, assume the parser can handle any file
+        if not supported_patterns:
+            return True
+            
+        # Check if the file matches any of the supported patterns
+        file_name = file_path.name
+        for pattern in supported_patterns:
+            if pattern.startswith("*"):
+                if file_name.endswith(pattern[1:]):
+                    return True
+            elif file_name == pattern:
+                return True
+                
+        return False

domd-2.2.8/src/domd/core/command_detection/parsers/parser_registry.py

@@ -0,0 +1,155 @@
+"""Registry for managing command parsers."""
+
+import importlib
+import inspect
+import logging
+import pkgutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Type, TypeVar, Union
+
+from .base_parser import BaseParser
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=BaseParser)
+
+
+class ParserRegistry:
+    """Registry for managing and discovering command parsers."""
+
+    def __init__(self):
+        """Initialize the parser registry."""
+        self._parsers: Dict[str, Type[BaseParser]] = {}
+        self._discovered = False
+
+    def register(self, parser_class: Type[T]) -> Type[T]:
+        """Register a parser class.
+
+        Args:
+            parser_class: Parser class to register
+
+        Returns:
+            The registered parser class (for use as a decorator)
+        """
+        if not inspect.isclass(parser_class) or not issubclass(
+            parser_class, BaseParser
+        ):
+            raise ValueError(
+                f"Parser must be a subclass of BaseParser, got {parser_class}"
+            )
+
+        parser_name = parser_class.__name__
+        self._parsers[parser_name] = parser_class
+        logger.debug(f"Registered parser: {parser_name}")
+        return parser_class
+
+    def get_parser(self, name: str) -> Optional[Type[BaseParser]]:
+        """Get a parser class by name.
+
+        Args:
+            name: Name of the parser class
+
+        Returns:
+            The parser class, or None if not found
+        """
+        return self._parsers.get(name)
+
+    def get_parsers(self) -> List[Type[BaseParser]]:
+        """Get all registered parser classes.
+
+        Returns:
+            List of parser classes
+        """
+        return list(self._parsers.values())
+
+    def create_parser_instances(self) -> List[BaseParser]:
+        """Create instances of all registered parsers.
+
+        Returns:
+            List of parser instances
+        """
+        return [parser() for parser in self._parsers.values()]
+
+    def discover_parsers(self, package_path: Optional[Union[str, Path]] = None) -> None:
+        """Discover and register parser classes in the given package.
+
+        Args:
+            package_path: Path to the package containing parser modules.
+                         If None, uses the default parsers directory.
+        """
+        if self._discovered:
+            return
+
+        if package_path is None:
+            # Default to the parsers directory in the same package
+            package_path = Path(__file__).parent / "parsers"
+            package = f"{__package__}.parsers"
+        else:
+            package_path = Path(package_path)
+            package = package_path.name
+
+        if not package_path.exists():
+            logger.warning(f"Parser directory not found: {package_path}")
+            return
+
+        logger.debug(f"Discovering parsers in {package_path}")
+
+        # Import all modules in the parsers directory
+        for finder, name, _ in pkgutil.iter_modules(
+            [str(package_path)], prefix=f"{package}."
+        ):
+            try:
+                # Skip __pycache__ and other non-module directories
+                if name.endswith("__pycache__"):
+                    continue
+
+                module = importlib.import_module(name)
+                self._register_parsers_from_module(module)
+            except ImportError as e:
+                logger.error(f"Failed to import parser module {name}: {e}")
+
+        self._discovered = True
+
+    def _register_parsers_from_module(self, module) -> None:
+        """Register all parser classes found in a module.
+
+        Args:
+            module: Python module to search for parser classes
+        """
+        for name, obj in inspect.getmembers(module):
+            if (
+                inspect.isclass(obj)
+                and issubclass(obj, BaseParser)
+                and obj is not BaseParser
+            ):
+                self.register(obj)
+                logger.debug(f"Discovered parser: {obj.__name__}")
+
+    def get_parser_for_file(self, file_path: Union[str, Path]) -> Optional[BaseParser]:
+        """Get an appropriate parser for the given file.
+
+        Args:
+            file_path: Path to the file to find a parser for
+
+        Returns:
+            Parser instance that can handle the file, or None if none found
+        """
+        file_path = Path(file_path)
+
+        # Try to find a parser that explicitly supports this file
+        for parser_class in self._parsers.values():
+            parser = parser_class()
+            if hasattr(parser, "can_parse") and parser.can_parse(file_path):
+                return parser
+
+        # Fall back to checking file extensions
+        for parser_class in self._parsers.values():
+            parser = parser_class()
+            if hasattr(parser, "get_supported_files"):
+                supported_files = parser.get_supported_files()
+                if supported_files and any(
+                    file_path.match(pat) for pat in supported_files
+                ):
+                    return parser
+
+        return None