domd 2.2.4__tar.gz → 2.2.6__tar.gz

{domd-2.2.4 → domd-2.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: domd
-Version: 2.2.4
+Version: 2.2.6
 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.4 → domd-2.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "domd"
-version = "2.2.4"
+version = "2.2.6"
 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.6/src/domd/core/command_detection/__init__.py

@@ -0,0 +1,18 @@
+"""Command detection module for finding and managing project commands."""
+
+from .base_detector import CommandDetector
+from .handlers import CommandHandler, ConfigFileHandler
+from .models import Command, CommandResult
+from .parsers import ParserRegistry
+from .utils import get_virtualenv_environment, get_virtualenv_info
+
+__all__ = [
+    "CommandDetector",
+    "CommandHandler",
+    "ConfigFileHandler",
+    "Command",
+    "CommandResult",
+    "ParserRegistry",
+    "get_virtualenv_info",
+    "get_virtualenv_environment",
+]

domd-2.2.6/src/domd/core/command_detection/base_detector.py

@@ -0,0 +1,195 @@
+"""Base command detector class for finding and managing project commands."""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from .handlers import CommandHandler, ConfigFileHandler
+from .models import Command, CommandResult
+from .parsers import ParserRegistry
+from .utils import get_virtualenv_info
+
+logger = logging.getLogger(__name__)
+
+
+class CommandDetector:
+    """Base class for detecting and managing project commands."""
+
+    def __init__(
+        self,
+        project_path: Union[str, Path] = ".",
+        timeout: int = 60,
+        exclude_patterns: Optional[List[str]] = None,
+        include_patterns: Optional[List[str]] = None,
+        todo_file: Union[str, Path] = "TODO.md",
+        done_file: Union[str, Path] = "DONE.md",
+        script_file: Union[str, Path] = "todo.sh",
+        ignore_file: str = ".doignore",
+        venv_path: Optional[str] = None,
+    ):
+        """Initialize the command detector.
+
+        Args:
+            project_path: Path to the project root
+            timeout: Command execution timeout in seconds
+            exclude_patterns: List of file patterns to exclude
+            include_patterns: List of file patterns to include
+            todo_file: Path to the TODO file
+            done_file: Path to the DONE file
+            script_file: Path to the script file
+            ignore_file: Path to the ignore file
+            venv_path: Path to the virtual environment
+        """
+        self.project_path = Path(project_path).resolve()
+        self.timeout = timeout
+        self.exclude_patterns = exclude_patterns or []
+        self.include_patterns = include_patterns or []
+
+        # Resolve file paths relative to project_path
+        self.todo_file = (self.project_path / Path(todo_file)).resolve()
+        self.done_file = (self.project_path / Path(done_file)).resolve()
+        self.script_file = (self.project_path / Path(script_file)).resolve()
+        self.ignore_file = self.project_path / Path(ignore_file)
+
+        # Initialize virtual environment
+        self.venv_path = venv_path
+        self.venv_info = get_virtualenv_info(venv_path or self.project_path)
+
+        # Command ignore patterns (separate from file exclude patterns)
+        self.ignore_patterns = []
+
+        # Initialize components
+        self._initialize_components()
+
+    def _initialize_components(self):
+        """Initialize all component handlers and services."""
+        # Initialize command execution components
+        self.command_executor = self._create_command_executor()
+        self.command_runner = self._create_command_runner()
+
+        # Initialize handlers
+        self.config_handler = self._create_config_handler()
+        self.command_handler = self._create_command_handler()
+
+        # Initialize parsers
+        self.parser_registry = self._create_parser_registry()
+        self.parsers = self._initialize_parsers()
+
+        # Initialize command storage
+        self._initialize_command_storage()
+
+    def _create_command_executor(self):
+        """Create and return a command executor instance."""
+        from ..services.command_executor import CommandExecutor
+
+        return CommandExecutor(timeout=self.timeout)
+
+    def _create_command_runner(self):
+        """Create and return a command runner instance."""
+        from ..services.command_runner import CommandRunner
+
+        return CommandRunner(executor=self.command_executor)
+
+    def _create_config_handler(self) -> ConfigFileHandler:
+        """Create and return a config file handler."""
+        return ConfigFileHandler(
+            project_path=self.project_path,
+            exclude_patterns=self.exclude_patterns,
+            include_patterns=self.include_patterns,
+            ignore_file=self.ignore_file,
+        )
+
+    def _create_command_handler(self) -> CommandHandler:
+        """Create and return a command handler."""
+        return CommandHandler(
+            project_path=self.project_path,
+            command_runner=self.command_runner,
+            timeout=self.timeout,
+            ignore_patterns=self.ignore_patterns,
+        )
+
+    def _create_parser_registry(self) -> ParserRegistry:
+        """Create and return a parser registry."""
+        return ParserRegistry()
+
+    def _initialize_command_storage(self):
+        """Initialize command storage references."""
+        self.failed_commands = self.command_handler.failed_commands
+        self.successful_commands = self.command_handler.successful_commands
+        self.ignored_commands = self.command_handler.ignored_commands
+
+    def _initialize_parsers(self) -> List[Any]:
+        """Initialize parsers for detecting commands in configuration files.
+
+        Returns:
+            List of parser instances
+        """
+        parsers = []
+
+        # Try to get parsers from registry first
+        try:
+            parsers = self.parser_registry.get_parsers()
+            logger.debug(
+                f"Found {len(parsers)} parser(s) in registry: "
+                f"{[p.__class__.__name__ for p in parsers]}"
+            )
+        except Exception as e:
+            logger.warning(f"Failed to get parsers from registry: {e}")
+            parsers = self._get_legacy_parsers()
+
+        logger.info(f"Initialized {len(parsers)} parsers")
+        return parsers
+
+    def _get_legacy_parsers(self) -> List[Any]:
+        """Get legacy parsers as fallback."""
+        try:
+            from domd.parsers import get_all_parsers
+
+            parser_classes = get_all_parsers()
+            return [cls() for cls in parser_classes]
+        except ImportError as e:
+            logger.warning(f"Failed to import legacy parsers: {e}")
+            return []
+
+    def scan_project(self) -> List[Command]:
+        """Scan the project for commands in configuration files.
+
+        This should be implemented by subclasses to provide specific
+        scanning behavior for different types of projects.
+
+        Returns:
+            List of Command objects
+        """
+        raise NotImplementedError("Subclasses must implement scan_project()")
+
+    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.command_handler.test_commands(commands)
+
+    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
+        """
+        return self.command_handler.should_ignore_command(command)
+
+    def get_ignore_reason(self, command: Union[str, Dict, Command]) -> Optional[str]:
+        """Get the reason why a command is ignored.
+
+        Args:
+            command: Command to check (string, dict, or Command object)
+
+        Returns:
+            Reason string or None if not ignored
+        """
+        if self.should_ignore_command(command):
+            return "Matched ignore pattern in .doignore file"
+        return None

domd-2.2.6/src/domd/core/command_detection/handlers/__init__.py

@@ -0,0 +1,6 @@
+"""Handlers for command detection and processing."""
+
+from .command_handler import CommandHandler
+from .config_handler import ConfigFileHandler
+
+__all__ = ["CommandHandler", "ConfigFileHandler"]

domd-2.2.6/src/domd/core/command_detection/models.py

@@ -0,0 +1,98 @@
+"""Data models for command detection and execution."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+
+@dataclass
+class CommandResult:
+    """Result of a command execution."""
+
+    command: str
+    return_code: int
+    stdout: str = ""
+    stderr: str = ""
+    success: bool = False
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    execution_time: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the result to a dictionary."""
+        return {
+            "command": self.command,
+            "return_code": self.return_code,
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+            "success": self.success,
+            "error": self.error,
+            "metadata": self.metadata,
+            "execution_time": self.execution_time,
+        }
+
+
+@dataclass
+class Command:
+    """Represents a command to be executed."""
+
+    command: str
+    type: str = ""
+    description: str = ""
+    source: str = ""
+    file: Union[str, Path] = ""
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    # These fields are populated during/after execution
+    return_code: Optional[int] = None
+    stdout: str = ""
+    stderr: str = ""
+    success: bool = False
+    error: Optional[str] = None
+    execution_time: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the command to a dictionary."""
+        return {
+            "command": self.command,
+            "type": self.type,
+            "description": self.description,
+            "source": self.source,
+            "file": str(self.file),
+            "metadata": self.metadata,
+            "return_code": self.return_code,
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+            "success": self.success,
+            "error": self.error,
+            "execution_time": self.execution_time,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Command":
+        """Create a Command from a dictionary."""
+        return cls(**data)
+
+
+@dataclass
+class CommandBatch:
+    """A batch of commands to be executed."""
+
+    commands: List[Command] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def add_command(self, command: Command) -> None:
+        """Add a command to the batch."""
+        self.commands.append(command)
+
+    def extend(self, commands: List[Command]) -> None:
+        """Extend the batch with multiple commands."""
+        self.commands.extend(commands)
+
+    def to_list(self) -> List[Dict[str, Any]]:
+        """Convert the batch to a list of command dictionaries."""
+        return [cmd.to_dict() for cmd in self.commands]
+
+    def __len__(self) -> int:
+        """Return the number of commands in the batch."""
+        return len(self.commands)

{domd-2.2.4 → domd-2.2.6}/src/domd/core/project_detection/detector.py

@@ -287,20 +287,32 @@ class ProjectCommandDetector:
                 return commands
 
             try:
-                # Read file content
-                content = file_path.read_text(encoding="utf-8")
+                # Set the file_path on the parser if it has that attribute
+                if hasattr(parser, "file_path"):
+                    parser.file_path = str(file_path)
 
-                # Parse commands from file content
+                # Parse commands from file
                 file_commands = []
                 if hasattr(parser, "parse_file") and callable(parser.parse_file):
-                    file_commands = parser.parse_file(file_path)
+                    file_commands = parser.parse_file(str(file_path))
                 elif hasattr(parser, "parse") and callable(parser.parse):
-                    # Try with content as string
+                    # First try without arguments (parser will handle file reading)
                     try:
-                        file_commands = parser.parse(content)
-                    except TypeError:
-                        # Last resort - try passing content as the first argument
-                        file_commands = parser.parse(content)
+                        file_commands = parser.parse()
+                    except (TypeError, AttributeError):
+                        # If that fails, try with file path
+                        try:
+                            file_commands = parser.parse(str(file_path))
+                        except (TypeError, AttributeError):
+                            # As a last resort, try with file content
+                            try:
+                                content = file_path.read_text(encoding="utf-8")
+                                file_commands = parser.parse(content)
+                            except Exception as e:
+                                logger.error(
+                                    f"Error parsing {file_path} with content: {e}"
+                                )
+                                return []
 
                 # Add file path to commands if not already present
                 for cmd in file_commands:

{domd-2.2.4 → domd-2.2.6}/src/domd/parsers/package_json.py

@@ -30,12 +30,15 @@ class PackageJsonParser(BaseParser):
     supported_file_patterns = ["package.json"]
 
     def parse(
-        self, file_path: Optional[Union[str, Path]] = None
+        self,
+        file_path: Optional[Union[str, Path]] = None,
+        content: Optional[str] = None,
     ) -> List[Dict[str, Any]]:
         """Parse package.json and extract npm scripts.
 
         Args:
             file_path: Path to the file to parse (overrides self.file_path if provided)
+            content: Optional content to parse instead of reading from file
 
         Returns:
             List of command dictionaries with 'command', 'description', 'source', and 'type' keys
@@ -43,15 +46,24 @@ class PackageJsonParser(BaseParser):
         if file_path is not None:
             self.file_path = Path(file_path).resolve()
 
-        if self.file_path is None or not self.file_path.exists():
-            logging.warning(f"File not found: {self.file_path}")
-            return []
+        if content is None:
+            if self.file_path is None or not self.file_path.exists():
+                logging.warning(f"File not found: {self.file_path}")
+                return []
+            try:
+                content = self.file_path.read_text(encoding="utf-8")
+            except Exception as e:
+                logging.error(f"Error reading file {self.file_path}: {e}")
+                return []
 
         self.initialize()
-        return self._parse_commands()
+        return self._parse_commands(content)
 
-    def _parse_commands(self) -> List[Dict[str, Any]]:
-        """Parse commands from package.json.
+    def _parse_commands(self, content: str) -> List[Dict[str, Any]]:
+        """Parse commands from package.json content.
+
+        Args:
+            content: The content of the package.json file
 
         Returns:
             List of command dictionaries with 'command', 'description', 'source', and 'type' keys
@@ -59,8 +71,7 @@ class PackageJsonParser(BaseParser):
         commands = []
 
         try:
-            with open(self.file_path, "r", encoding="utf-8") as f:
-                data = json.load(f)
+            data = json.loads(content)
 
             # Extract scripts
             scripts = data.get("scripts", {})