domd 2.2.30__tar.gz → 2.2.32__tar.gz

{domd-2.2.30 → domd-2.2.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: domd
-Version: 2.2.30
+Version: 2.2.32
 Summary:  ✓ DoMD - Do Markdown Docs - automatically detect, run and show working commands in DONE.md and errors in TODO.md markdown files
 License: Apache-2.0
 Author: Tom Sapletta

{domd-2.2.30 → domd-2.2.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "domd"
-version = "2.2.30"
+version = "2.2.32"
 description = " ✓ DoMD - Do Markdown Docs - automatically detect, run and show working commands in DONE.md and errors in TODO.md markdown files"
 authors = ["Tom Sapletta <info@softreck.dev>"]
 maintainers = ["WRONAI Team"]

{domd-2.2.30 → domd-2.2.32}/src/domd/adapters/persistence/shell_command_executor.py

@@ -141,6 +141,17 @@ class ShellCommandExecutor(CommandExecutor):
 
         cmd_args, needs_shell = self._parse_command(cmd_str)
 
+        # If cmd_args is empty, this is markdown content that should be ignored
+        if not cmd_args:
+            logger.debug(f"Skipping markdown content: {cmd_str[:100]}...")
+            return CommandResult(
+                success=True,
+                return_code=0,
+                execution_time=0,
+                stdout="",
+                stderr="",
+            )
+
         # Prepare execution environment
         execution_env = None
         if env:
@@ -282,44 +293,111 @@ class ShellCommandExecutor(CommandExecutor):
 
     def _is_markdown_content(self, command_str: str) -> bool:
         """
-        Check if the given string appears to be markdown content.
+        Check if the given string appears to be markdown or other non-command content.
 
         Args:
             command_str: The string to check
 
         Returns:
-            bool: True if the string appears to be markdown content
+            bool: True if the string appears to be non-command content
         """
+        # Skip empty strings
+        if not command_str or not command_str.strip():
+            return True
+
         # Common markdown patterns that shouldn't be executed as commands
-        markdown_indicators = [
+        markdown_patterns = [
             # Headers
-            r"^#+\s",
+            (r"^#+\s+", "Markdown header"),
             # Lists
-            r"^\s*[-*+]\s+",
-            r"^\s*\d+\.\s+",
+            (r"^[-*+]\s+", "Markdown list item"),
+            (r"^\d+\.\s+", "Numbered list item"),
             # Code blocks
-            r"^\s*```",
+            (r"^```", "Markdown code block"),
+            (r"`[^`]+`", "Inline code"),
             # Tables
-            r"\|.*\|",
+            (r"^\|.*\|$", "Markdown table"),
             # Links and images
-            r"\[.*\]\(.*\)",
+            (r"\[.*\]\(.*\)", "Markdown link"),
+            (r"!\[.*\]\(.*\)", "Markdown image"),
+            # Text formatting
+            (r"\*\*[^*]+\*\*", "Bold text"),
+            (r"__[^_]+__", "Underlined text"),
+            (r"~~[^~]+~~", "Strikethrough"),
+            (r"\*[^*]+\*", "Italic text"),
+            (r"_[^_]+_", "Italic text (underscore)"),
             # Blockquotes
-            r"^>",
+            (r"^>\s+", "Blockquote"),
             # Horizontal rules
-            r"^[-*_]{3,}$",
-            # Box-drawing characters (used in tree views)
-            r"[├└│]",
-            # Common markdown file extensions
-            r"\.md$",
+            (r"^\s*[*_-]{3,}\s*$", "Horizontal rule"),
+            # HTML tags
+            (r"<[a-z][\s\S]*?>", "HTML tag"),
+            # Common documentation patterns
+            (r"^\s*[A-Z][A-Za-z0-9_\s-]+:", "Documentation line"),
+            (r"^\s*<!--.*-->\s*$", "HTML comment"),
+            (r"^\s*//", "Single-line comment"),
+            (r"^\s*#", "Comment"),
+            (r"^\s*/\*[\s\S]*?\*/\s*$", "Multi-line comment"),
+            # Common metadata patterns
+            (r"^\s*[\w-]+\s*:\s*.+", "YAML/JSON key-value pair"),
+            # Directory listing patterns
+            (r"^[│└├─]", "Tree-like directory structure"),
+            (r"\s+\d+\s+\w+\s+\d+\s+[\d:]+\s+", "File size and date"),
+            (r"\d+\s+[BKMGTPEZY]B\s*$", "File size"),
+            (r"^total \d+$", "Directory total"),
+            # Common documentation sections
+            (
+                r"^\s*(Installation|Usage|Configuration|Options|Examples):",
+                "Documentation section",
+            ),
+            # Empty or whitespace-only lines
+            (r"^\s*$", "Empty line"),
         ]
 
-        # Check for markdown indicators
-        for pattern in markdown_indicators:
-            if re.search(pattern, command_str):
+        # Check for markdown and other non-command patterns
+        for pattern, description in markdown_patterns:
+            if re.search(pattern, command_str, re.MULTILINE):
+                logger.debug(f"Detected {description}: {command_str[:100]}")
                 return True
 
-        # Check if this looks like a documentation line (e.g., starts with a word and colon)
-        if re.match(r"^\s*[A-Za-z][A-Za-z0-9_\s-]*:", command_str):
+        # Check for suspiciously long lines that aren't commands
+        if len(command_str) > 1000 and not any(
+            c in command_str for c in ["&&", "|", ">", "<", ";"]
+        ):
+            logger.debug(f"Suspiciously long line detected: {command_str[:100]}...")
+            return True
+
+        # Check for lines that are just special characters or numbers
+        if re.match(r"^[\d\s\W]+$", command_str):
+            logger.debug(
+                f"Line contains only numbers/special chars: {command_str[:100]}"
+            )
+            return True
+
+        # Check for common error messages or stack traces
+        error_indicators = [
+            "error:",
+            "warning:",
+            "exception:",
+            "traceback",
+            "stacktrace",
+            "at ",
+            'File "',
+            r"line \d+",  # Raw string for regex
+            "in <module>",
+            "^",
+            "~",
+            "SyntaxError",
+            "NameError",
+            "TypeError",
+            "ValueError",
+            "ImportError",
+        ]
+
+        if any(
+            indicator.lower() in command_str.lower() for indicator in error_indicators
+        ):
+            logger.debug(f"Error/warning message detected: {command_str[:100]}...")
             return True
 
         return False
@@ -334,21 +412,23 @@ class ShellCommandExecutor(CommandExecutor):
         Returns:
             Tuple of (command_args, needs_shell)
         """
-        if not command_str.strip():
-            return [], False
+        # Handle empty or whitespace-only commands
+        if not command_str or not command_str.strip():
+            logger.debug("Empty or whitespace-only command")
+            return [""], False  # Return a non-empty list to avoid IndexError
+
+        command_str = command_str.strip()
 
         # Check if this is markdown content that shouldn't be executed
         if self._is_markdown_content(command_str):
             logger.debug(f"Ignoring markdown content: {command_str[:100]}...")
-            return [], False
+            return [""], False  # Return a non-empty list to avoid IndexError
 
         # Check if this is a shell built-in or needs shell features
         needs_shell = self._needs_shell(command_str)
 
         # Special handling for 'source' command
-        if command_str.strip().startswith("source ") or command_str.strip().startswith(
-            ". "
-        ):
+        if command_str.startswith("source ") or command_str.startswith(". "):
             # For 'source' command, we need to use the shell to execute it
             return [command_str], True
 
@@ -358,9 +438,13 @@ class ShellCommandExecutor(CommandExecutor):
 
         # For non-shell commands, use shlex for proper argument splitting
         try:
-            return shlex.split(command_str), False
+            args = shlex.split(command_str)
+            if not args:  # Handle case where shlex.split returns empty list
+                return [""], False
+            return args, False
         except Exception as e:
             logger.warning(
                 f"Error parsing command with shlex, falling back to simple split: {e}"
             )
-            return command_str.split(), False
+            args = command_str.split()
+            return (args if args else [""]), False

{domd-2.2.30 → domd-2.2.32}/src/domd/core/command_detection/handlers/command_handler.py

@@ -6,7 +6,8 @@ import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-from ...services.command_runner import CommandRunner
+from domd.core.command_execution.command_runner import CommandRunner
+
 from ..models import Command
 
 logger = logging.getLogger(__name__)
@@ -162,63 +163,186 @@ class CommandHandler:
     def is_valid_command(self, command: Union[str, Dict, Command]) -> tuple[bool, str]:
         """Check if a command is valid and should be executed.
 
+        This method performs multiple validations to ensure the command is a valid shell command
+        and not markdown, documentation, or other non-command content.
+
         Args:
             command: Command to validate (string, dict, or Command object)
 
         Returns:
             Tuple of (is_valid, reason) where is_valid is a boolean and reason is a string
         """
+        logger.debug(f"Validating command: {command}")
+
         cmd_str = self._extract_command_string(command)
         if not cmd_str or not cmd_str.strip():
+            logger.debug("Empty command string")
+            return False, "Empty command"
+
+        cmd_str = cmd_str.strip()
+        logger.debug(
+            f"Processing command: {cmd_str[:100]}"
+            + ("..." if len(cmd_str) > 100 else "")
+        )
+
+        # Check for empty or whitespace-only commands
+        if not cmd_str:
+            logger.debug("Command is empty after stripping")
             return False, "Empty command"
 
-        # Check if the command looks like a markdown header, list item, or other content
-        if any(markdown_indicator in cmd_str for markdown_indicator in [
-            "# ",  # Headers
-            "- ",  # List items
-            "* ",  # List items
-            "1. ",  # Numbered lists
-            "| ",  # Tables
-            "```",  # Code blocks
-            "**",  # Bold text
-            "__",  # Underlined text
-            "~~",  # Strikethrough
-            "[]",  # Links
-            "![",  # Images
-            "<",   # HTML tags
-            "> "   # Blockquotes
-        ]):
-            return False, "Appears to be markdown content"
-
-        # Check against non-command patterns
+        # Check for very long commands (likely not actual commands)
+        if len(cmd_str) > 500:
+            logger.debug(f"Command too long ({len(cmd_str)} > 500 characters)")
+            return False, "Command is too long to be a valid shell command"
+
+        # Check for commands that are just numbers or special characters
+        if re.match(r"^[\d\s\W]+$", cmd_str):
+            logger.debug("Command contains only numbers or special characters")
+            return False, "Command contains only numbers or special characters"
+
+        # Check for common non-command patterns first (fast checks)
         for pattern in self._compiled_non_command_patterns:
             if pattern.search(cmd_str):
+                logger.debug(f"Matches non-command pattern: {pattern.pattern}")
                 return False, f"Matches non-command pattern: {pattern.pattern}"
 
-        # Check for common error patterns
-        if any(s in cmd_str.lower() for s in ["error:", "warning:", "exception:", "traceback"]):
-            return False, "Appears to be an error or warning message"
+        # Enhanced markdown and documentation detection with detailed logging
+        markdown_patterns = [
+            # Markdown patterns
+            (r"^#+\s+", "Markdown header"),
+            (r"^[-*+]\s+", "Markdown list item"),
+            (r"^\d+\.\s+", "Numbered list item"),
+            (r"^\|.*\|$", "Markdown table"),
+            (r"^```", "Markdown code block"),
+            (r"`[^`]+`", "Inline code"),
+            (r"\*\*[^*]+\*\*", "Bold text"),
+            (r"__[^_]+__", "Underlined text"),
+            (r"~~[^~]+~~", "Strikethrough"),
+            (r"\[.*\]\(.*\)", "Markdown link"),
+            (r"^>\s+", "Blockquote"),
+            (r"^\s*<!--.*-->\s*$", "HTML comment"),
+            # Documentation patterns
+            (r"^For\s+\w+\s+information", "Documentation line"),
+            (r"^To\s+\w+", "Documentation line"),
+            (r"^This\s+\w+", "Documentation line"),
+            (r"^The\s+\w+", "Documentation line"),
+            (r"^[A-Z][a-z]+\s+the\s+\w+", "Documentation line"),
+            (r"^[A-Z][a-z]+\s+[A-Z][a-z]+", "Documentation line"),
+            (r"^[A-Z][a-z]+\s+[a-z]+\s+[a-z]+", "Documentation line"),
+            # Directory tree patterns
+            (r"^\s*[│├└─]+\s+", "Directory tree"),
+            (r"^\s*[│├└─]+$", "Directory tree connector"),
+            (r"^\s*\d+\s+[a-z]+\s+\d+\s+\d{2}:\d{2}\s+", "Directory listing"),
+        ]
 
-        # Check for documentation-style lines (e.g., "parameter: value")
-        if re.match(r'^\s*[A-Za-z][A-Za-z0-9_\s-]*:', cmd_str):
-            return False, "Appears to be documentation or configuration"
+        logger.debug(f"Checking against {len(markdown_patterns)} markdown patterns")
+
+        # Additional patterns to check with detailed logging
+        additional_patterns = [
+            # Common documentation phrases
+            (r"(?i)for more information", "Documentation phrase"),
+            (r"(?i)see also", "Documentation phrase"),
+            (r"(?i)example:", "Documentation phrase"),
+            (r"(?i)note:", "Documentation note"),
+            (r"(?i)warning:", "Warning message"),
+            (r"(?i)important:", "Important note"),
+            (r"(?i)tip:", "Tip note"),
+            (r"(?i)caution:", "Caution note"),
+            (r"(?i)see the", "Documentation reference"),
+            (r"(?i)refer to", "Documentation reference"),
+            # Common command-like patterns that should be ignored
+            (r"^\s*\w+\s*=\s*\S+\s*$", "Variable assignment"),
+            (r"^\s*\{\s*\}\s*$", "Empty code block"),
+            (r"^\s*\[\s*\]\s*$", "Empty array"),
+            (r"^\s*\{\s*$", "Opening brace"),
+            (r"^\s*\}\s*$", "Closing brace"),
+            # Common error patterns
+            (r"(?i)error:", "Error message"),
+            (r"(?i)exception:", "Exception message"),
+            (r"(?i)traceback", "Traceback message"),
+            (r"(?i)stacktrace", "Stack trace"),
+            # Path patterns
+            (r"^\s*/[\w/.-]+$", "File path"),
+            (r"^\s*~?/[\w/.-]+$", "Home-relative path"),
+            (r"^\s*\./[\w/.-]+$", "Relative path"),
+            # URL patterns
+            (r"https?://\S+", "URL"),
+            (r"www\.\S+\.\w+", "Web address"),
+            # Email patterns
+            (r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b", "Email address"),
+        ]
 
-        # Check for suspicious patterns that might indicate internal errors
-        if any(s in cmd_str.lower() for s in ["traceback", "exception", "stacktrace"]):
-            return False, "Appears to contain error output"
+        logger.debug(f"Checking against {len(additional_patterns)} additional patterns")
 
-        # Check for internal tool paths that shouldn't be executed
-        if any(s in cmd_str for s in ["/tmp/", "/var/", "/usr/local/", "~/.cache/", "/dev/"]):
-            return False, "References internal tool paths"
+        # Combine all patterns
+        all_patterns = markdown_patterns + additional_patterns
+        logger.debug(f"Total patterns to check: {len(all_patterns)}")
 
-        # Check for commands that are just numbers or special characters
-        if re.match(r'^[\d\s\W]+$', cmd_str):
-            return False, "Contains only numbers or special characters"
+        # Check all patterns with detailed logging
+        for pattern, description in all_patterns:
+            try:
+                if re.search(pattern, cmd_str, re.IGNORECASE):
+                    logger.debug(
+                        f"Pattern matched - Type: {description}, Pattern: {pattern}"
+                    )
+                    return False, f"{description} detected"
+            except Exception as e:
+                logger.error(f"Error checking pattern '{pattern}': {str(e)}")
+                continue
+
+        logger.debug("No markdown or documentation patterns matched")
+
+        # Check for command-like patterns that might be valid
+        valid_command_indicators = [
+            (r"^\s*[a-z][a-z0-9_-]+(\s+[a-z][a-z0-9_-]+)*\s*$", "Simple command"),
+            (r"^\s*[a-z][a-z0-9_-]+\s+[a-z][a-z0-9_-]+", "Command with argument"),
+            (r"^\s*[a-z][a-z0-9_-]+\s+--?[a-z0-9-]+", "Command with option"),
+            (
+                r"^\s*[a-z][a-z0-9_-]+\s+[a-z][a-z0-9_-]+\s+[a-z][a-z0-9_-]+",
+                "Command with multiple args",
+            ),
+        ]
+
+        logger.debug("Checking command against valid command patterns")
+
+        # Track if any command pattern matches
+        command_matched = False
+        for pattern, pattern_type in valid_command_indicators:
+            try:
+                if re.match(pattern, cmd_str, re.IGNORECASE):
+                    logger.debug(f"Command matches {pattern_type} pattern: {pattern}")
+                    command_matched = True
+                    break
+            except Exception as e:
+                logger.error(f"Error checking command pattern '{pattern}': {str(e)}")
+
+        if not command_matched:
+            logger.debug("Command does not match any valid command patterns")
+            return False, "Does not match valid command patterns"
+
+        # Check for commands that are too short or too simple
+        if len(cmd_str.split()) == 1 and len(cmd_str) < 3:
+            logger.debug("Command is too short or simple")
+            return False, "Command is too short or simple"
 
-        # Check for very long commands that are likely not actual commands
-        if len(cmd_str) > 500:  # Arbitrary length threshold
+        # Check for commands that are too long (likely not actual commands)
+        if len(cmd_str) > 500:
+            logger.debug(f"Command is too long ({len(cmd_str)} characters)")
             return False, "Command is too long to be a valid shell command"
 
+        # Check for commands that are just numbers or special characters
+        if re.match(r"^[\d\s\W]+$", cmd_str):
+            logger.debug("Command contains only numbers or special characters")
+            return False, "Command contains only numbers or special characters"
+
+        # Check for internal tool paths that shouldn't be executed
+        internal_paths = ["/tmp/", "/var/", "/usr/local/", "~/.cache/", "/dev/"]
+        for path in internal_paths:
+            if path in cmd_str:
+                logger.debug(f"Command references internal tool path: {path}")
+                return False, f"References internal tool path: {path}"
+
+        logger.debug("Command passed all validation checks")
         return True, ""
 
     def should_ignore_command(self, command: Union[str, Dict, Command]) -> bool:

{domd-2.2.30 → domd-2.2.32}/src/domd/core/command_detection/handlers/config_handler.py

@@ -4,8 +4,8 @@ import logging
 from pathlib import Path
 from typing import Any, List, Optional, Set, Union
 
-from ...services.file_processor import FileProcessor
-from ...services.pattern_matcher import PatternMatcher
+from domd.core.parsing.file_processor import FileProcessor
+from domd.core.parsing.pattern_matcher import PatternMatcher
 
 logger = logging.getLogger(__name__)
 

{domd-2.2.30 → domd-2.2.32}/src/domd/core/command_detection/parsers/base_parser.py

@@ -5,7 +5,7 @@ import logging
 from pathlib import Path
 from typing import List, Optional, Set, Union
 
-from ...models import Command
+from ..models import Command
 
 logger = logging.getLogger(__name__)