domd 2.2.28__tar.gz → 2.2.30__tar.gz

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "domd"
-version = "2.2.28"
+version = "2.2.30"
 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.28 → domd-2.2.30}/src/domd/adapters/persistence/shell_command_executor.py

@@ -5,6 +5,7 @@ Implementacja wykonawcy komend powłoki systemowej.
 # Standard library imports
 import logging
 import os
+import re
 import shlex
 import subprocess
 import time
@@ -279,6 +280,50 @@ class ShellCommandExecutor(CommandExecutor):
 
         return False
 
+    def _is_markdown_content(self, command_str: str) -> bool:
+        """
+        Check if the given string appears to be markdown content.
+
+        Args:
+            command_str: The string to check
+
+        Returns:
+            bool: True if the string appears to be markdown content
+        """
+        # Common markdown patterns that shouldn't be executed as commands
+        markdown_indicators = [
+            # Headers
+            r"^#+\s",
+            # Lists
+            r"^\s*[-*+]\s+",
+            r"^\s*\d+\.\s+",
+            # Code blocks
+            r"^\s*```",
+            # Tables
+            r"\|.*\|",
+            # Links and images
+            r"\[.*\]\(.*\)",
+            # Blockquotes
+            r"^>",
+            # Horizontal rules
+            r"^[-*_]{3,}$",
+            # Box-drawing characters (used in tree views)
+            r"[├└│]",
+            # Common markdown file extensions
+            r"\.md$",
+        ]
+
+        # Check for markdown indicators
+        for pattern in markdown_indicators:
+            if re.search(pattern, command_str):
+                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):
+            return True
+
+        return False
+
     def _parse_command(self, command_str: str) -> Tuple[List[str], bool]:
         """
         Parses a command string into a list of arguments and determines if it needs a shell.
@@ -292,6 +337,11 @@ class ShellCommandExecutor(CommandExecutor):
         if not command_str.strip():
             return [], False
 
+        # 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
+
         # Check if this is a shell built-in or needs shell features
         needs_shell = self._needs_shell(command_str)
 

{domd-2.2.28 → domd-2.2.30}/src/domd/cli.py

@@ -549,7 +549,7 @@ def main() -> int:
             return 0
 
         # Test commands with real-time updates
-        if not getattr(args, 'quiet', False):
+        if not getattr(args, "quiet", False):
             print(f"\n🧪 Testing {len(commands)} commands...")
             print(
                 f"📊 Progress will be updated in {getattr(args, 'todo_file', 'TODO.md')}"

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

@@ -159,7 +159,7 @@ class CommandHandler:
                 "execution_time": 0,
             }
 
-    def is_valid_command(self, command: Union[str, Dict, Command]) -> bool:
+    def is_valid_command(self, command: Union[str, Dict, Command]) -> tuple[bool, str]:
         """Check if a command is valid and should be executed.
 
         Args:
@@ -172,22 +172,52 @@ class CommandHandler:
         if not cmd_str or not cmd_str.strip():
             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
         for pattern in self._compiled_non_command_patterns:
             if pattern.search(cmd_str):
                 return False, f"Matches non-command pattern: {pattern.pattern}"
 
         # Check for common error patterns
-        if "error:" in cmd_str.lower() or "warning:" in cmd_str.lower():
-            return False, "Command appears to be an error or warning message"
+        if any(s in cmd_str.lower() for s in ["error:", "warning:", "exception:", "traceback"]):
+            return False, "Appears to be an error or warning message"
+
+        # 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"
 
         # Check for suspicious patterns that might indicate internal errors
         if any(s in cmd_str.lower() for s in ["traceback", "exception", "stacktrace"]):
-            return False, "Command appears to contain error output"
+            return False, "Appears to contain error output"
 
         # Check for internal tool paths that shouldn't be executed
-        if any(s in cmd_str for s in ["/tmp/", "/var/", "/usr/local/", "~/.cache/"]):
-            return False, "Command references internal tool paths"
+        if any(s in cmd_str for s in ["/tmp/", "/var/", "/usr/local/", "~/.cache/", "/dev/"]):
+            return False, "References internal tool paths"
+
+        # 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 for very long commands that are likely not actual commands
+        if len(cmd_str) > 500:  # Arbitrary length threshold
+            return False, "Command is too long to be a valid shell command"
 
         return True, ""