domd 2.2.24__tar.gz → 2.2.26__tar.gz

{domd-2.2.24 → domd-2.2.26}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "domd"
-version = "2.2.24"
+version = "2.2.26"
 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.24 → domd-2.2.26}/src/domd/cli.py

@@ -32,37 +32,34 @@ logger = logging.getLogger(__name__)
 
 def _check_node_installed() -> bool:
     """Check if Node.js and npm are installed.
-    
+
     Returns:
         bool: True if both Node.js and npm are installed, False otherwise
     """
     try:
         # Check Node.js
         node_version = subprocess.check_output(
-            ["node", "--version"], 
-            stderr=subprocess.PIPE,
-            universal_newlines=True
+            ["node", "--version"], stderr=subprocess.PIPE, universal_newlines=True
         ).strip()
-        
+
         # Check npm
         npm_version = subprocess.check_output(
-            ["npm", "--version"], 
-            stderr=subprocess.PIPE,
-            universal_newlines=True
+            ["npm", "--version"], stderr=subprocess.PIPE, universal_newlines=True
         ).strip()
-        
+
         print(f"✓ Found {node_version} and npm {npm_version}")
         return True
-        
+
     except (subprocess.CalledProcessError, FileNotFoundError):
         return False
 
+
 def _install_dependencies(frontend_dir: Path) -> bool:
     """Install frontend dependencies using npm.
-    
+
     Args:
         frontend_dir: Path to the frontend directory
-        
+
     Returns:
         bool: True if installation was successful, False otherwise
     """
@@ -80,59 +77,62 @@ def _install_dependencies(frontend_dir: Path) -> bool:
         print(f"❌ Failed to install dependencies: {e}")
         return False
 
+
 def start_web_interface(args: argparse.Namespace) -> int:
     """Start the web interface.
-    
+
     Args:
         args: Command line arguments
-        
+
     Returns:
         int: Exit code (0 for success, non-zero for error)
     """
     port = args.port
     open_browser = not args.no_browser
-    
+
     # Check if Node.js and npm are installed
     print("🔍 Checking for Node.js and npm...")
     if not _check_node_installed():
-        print("""
+        print(
+            """
 ❌ Node.js and npm are required to run the web interface.
    Please install them from https://nodejs.org/ and try again.
-   
+
    On Ubuntu/Debian: sudo apt-get install nodejs npm
    On macOS:          brew install node
    On Windows:        Download from https://nodejs.org/
-        """)
+        """
+        )
         return 1
-    
+
     # Get the directory of this file
     current_dir = Path(__file__).parent
     frontend_dir = current_dir.parent.parent / "frontend"
-    
+
     if not frontend_dir.exists():
         print(f"❌ Error: Frontend directory not found at {frontend_dir}")
         return 1
-        
+
     # Check if node_modules exists, if not, install dependencies
     if not (frontend_dir / "node_modules").exists():
         if not _install_dependencies(frontend_dir):
             return 1
-    
+
     # Change to the frontend directory
     os.chdir(frontend_dir)
-    
+
     # Set the port environment variable
     os.environ["PORT"] = str(port)
-    
+
     print(f"🚀 Starting DoMD web interface on port {port}...")
     print("   Press Ctrl+C to stop the server")
-    
+
     # Start the React development server
     try:
         cmd = ["npm", "start"]
         if sys.platform == "win32":
             cmd = ["npm.cmd", "start"]
-            
+
         # Start the process
         process = subprocess.Popen(
             cmd,
@@ -141,25 +141,25 @@ def start_web_interface(args: argparse.Namespace) -> int:
             stderr=subprocess.STDOUT,
             universal_newlines=True,
         )
-        
+
         # Open browser after a short delay
         if open_browser:
             time.sleep(2)  # Give the server a moment to start
             print(f"🌐 Opening browser to http://localhost:{port}...")
             webbrowser.open(f"http://localhost:{port}")
-            
+
         # Stream the output
         for line in process.stdout:
             print(line, end="")
-            
+
         # Wait for the process to complete
         process.wait()
         return process.returncode
-        
+
     except KeyboardInterrupt:
         print("\n🛑 Web interface stopped by user")
         return 0
-        
+
     except Exception as e:
         print(f"❌ Error starting web interface: {e}")
         print("\n💡 Try these troubleshooting steps:")

{domd-2.2.24 → domd-2.2.26}/src/domd/core/command_execution/command_executor.py

@@ -4,6 +4,7 @@ import logging
 import os
 import shlex
 import subprocess
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Type, TypeVar, Union

{domd-2.2.24 → domd-2.2.26}/src/domd/core/parsers/ansible_playbook.py

@@ -54,31 +54,41 @@ class AnsiblePlaybookParser(BaseParser):
         """
         from domd.core.commands import Command
 
-        if not self.file_path or not self.file_path.exists():
+        if not hasattr(self, "file_path") or self.file_path is None:
             return []
 
         self._commands: List[Command] = []
 
         # If content is not provided, read from file
-        if content is None and not self.file_path.is_dir():
+        if (
+            content is None
+            and hasattr(self, "file_path")
+            and not self.file_path.is_dir()
+        ):
             try:
-                with open(self.file_path, "r", encoding="utf-8") as f:
+                with open(str(self.file_path), "r", encoding="utf-8") as f:
                     content = f.read()
-            except (IOError, UnicodeDecodeError):
+            except (IOError, UnicodeDecodeError) as e:
                 # If we can't read the file, return empty list
+                import logging
+
+                logger = logging.getLogger(__name__)
+                logger.warning(f"Error reading file {self.file_path}: {e}")
                 return []
 
         try:
-            playbook = yaml.safe_load(content)
+            playbook = yaml.safe_load(content) if content else []
 
             if not isinstance(playbook, list):
                 return []
 
             # Get relative path if file is in project directory, otherwise use full path
-            try:
-                playbook_path = self.file_path.relative_to(self.project_root)
-            except ValueError:
-                playbook_path = self.file_path
+            playbook_path = str(self.file_path)
+            if hasattr(self, "project_root") and self.project_root:
+                try:
+                    playbook_path = str(self.file_path.relative_to(self.project_root))
+                except ValueError:
+                    pass
 
             for play in playbook:
                 if not isinstance(play, dict):

{domd-2.2.24 → domd-2.2.26}/src/domd/core/project_detection/command_handling.py

@@ -250,18 +250,30 @@ class CommandHandler:
                 bin_dir = "bin"
                 python_exe = "python"
 
-            python_path = os.path.join(venv_path, bin_dir, python_exe)
-            if os.path.isfile(python_path):
+            # First try the direct path from venv_env if available
+            python_path = venv_env.get("python_path")
+            if not python_path or not os.path.isfile(python_path):
+                # Fall back to standard location
+                python_path = os.path.join(venv_path, bin_dir, python_exe)
+
+                # If that doesn't exist, try version-specific python
+                if not os.path.isfile(python_path):
+                    python_path = os.path.join(
+                        venv_path,
+                        bin_dir,
+                        f"python{sys.version_info.major}.{sys.version_info.minor}",
+                    )
+                    # If still not found, try without minor version
+                    if not os.path.isfile(python_path):
+                        python_path = os.path.join(
+                            venv_path,
+                            bin_dir,
+                            f"python{sys.version_info.major}",
+                        )
+
+            # If we found a valid Python executable, use it
+            if python_path and os.path.isfile(python_path):
                 cmd_list[0] = python_path
-            else:
-                # Fallback to the Python executable in the virtualenv's bin directory
-                python_path = os.path.join(
-                    venv_path,
-                    bin_dir,
-                    f"python{sys.version_info.major}.{sys.version_info.minor}",
-                )
-                if os.path.isfile(python_path):
-                    cmd_list[0] = python_path
 
         # Merge environments, with user-provided env taking precedence
         env = kwargs.pop("env", {})

{domd-2.2.24 → domd-2.2.26}/src/domd/core/project_detection/detector.py

@@ -1,6 +1,7 @@
 """Project command detector for finding and executing commands in project files."""
 
 import logging
+import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
@@ -263,78 +264,137 @@ class ProjectCommandDetector:
         all_commands.extend(commands)
         logger.info(f"Found {len(commands)} commands in {display_path}")
 
-    def _process_file_commands(self, file_path: Path) -> List[Dict]:
+    def _process_file_commands(self, file_path: Union[str, Path]) -> List[Dict]:
         """Process a single file and extract commands.
 
         Args:
-            file_path: Path to the file to process
+            file_path: Path to the file to process (can be str or Path)
 
         Returns:
             List of command dictionaries with metadata
         """
-        logger.debug(f"Processing file: {file_path}")
+        # Convert to Path object if needed
+        path = Path(file_path) if isinstance(file_path, str) else file_path
+        logger.debug(f"Processing file: {path}")
         commands = []
 
         try:
-            if not file_path.exists():
-                logger.warning(f"File not found: {file_path}")
+            # Check if file exists and is a file
+            if not path.exists():
+                logger.warning(f"File not found: {path}")
+                return commands
+
+            if not path.is_file():
+                logger.debug(f"Path is not a file: {path}")
                 return commands
 
             # Get the appropriate parser for the file
-            parser = self._get_parser_for_file(file_path)
+            parser = self._get_parser_for_file(path)
             if not parser:
-                logger.debug(f"No parser found for file: {file_path}")
+                logger.debug(f"No suitable parser found for file: {path}")
                 return commands
 
-            try:
-                # Set the file_path on the parser if it has that attribute
-                if hasattr(parser, "file_path"):
-                    parser.file_path = str(file_path)
+            # Set the file_path on the parser if it has that attribute
+            if hasattr(parser, "file_path"):
+                parser.file_path = path
 
-                # Parse commands from file
-                file_commands = []
+            # Set project root if needed
+            if hasattr(parser, "project_root") and not hasattr(
+                parser, "_project_root_set"
+            ):
+                parser.project_root = self.project_path
+                parser._project_root_set = True
+
+            # Parse commands from file
+            file_commands = []
+            try:
+                # Try different parsing methods in order of preference
                 if hasattr(parser, "parse_file") and callable(parser.parse_file):
-                    file_commands = parser.parse_file(str(file_path))
+                    file_commands = parser.parse_file(path)
                 elif hasattr(parser, "parse") and callable(parser.parse):
                     # First try without arguments (parser will handle file reading)
                     try:
                         file_commands = parser.parse()
-                    except (TypeError, AttributeError):
+                    except (TypeError, AttributeError) as e:
+                        logger.debug(
+                            f"Parser.parse() failed, trying with file path: {e}"
+                        )
                         # If that fails, try with file path
                         try:
-                            file_commands = parser.parse(str(file_path))
-                        except (TypeError, AttributeError):
+                            file_commands = parser.parse(path)
+                        except (TypeError, AttributeError) as e:
+                            logger.debug(
+                                f"Parser.parse(path) failed, trying with file content: {e}"
+                            )
                             # As a last resort, try with file content
                             try:
-                                content = file_path.read_text(encoding="utf-8")
+                                content = 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}"
+                                    f"Error parsing {path} with content: {e}",
+                                    exc_info=logger.isEnabledFor(logging.DEBUG),
                                 )
                                 return []
 
-                # Add file path to commands if not already present
+                if not isinstance(file_commands, list):
+                    logger.warning(
+                        f"Parser returned non-list result: {type(file_commands)}"
+                    )
+                    file_commands = []
+
+                # Process the parsed commands
+                processed_commands = []
                 for cmd in file_commands:
-                    if isinstance(cmd, dict):
-                        cmd["file"] = str(file_path)
-                        # Add relative path as source if not present
-                        if "source" not in cmd:
-                            cmd["source"] = str(
-                                file_path.relative_to(self.project_path)
-                            )
-                    elif hasattr(cmd, "file") and not cmd.file:
-                        cmd.file = str(file_path)
-                        if not hasattr(cmd, "source") or not cmd.source:
-                            cmd.source = str(file_path.relative_to(self.project_path))
+                    try:
+                        if cmd is None:
+                            continue
+
+                        # Handle both dict and object-style commands
+                        if isinstance(cmd, dict):
+                            # Ensure required fields exist
+                            cmd.setdefault("file", str(path))
+                            if "source" not in cmd:
+                                try:
+                                    cmd["source"] = str(
+                                        path.relative_to(self.project_path)
+                                    )
+                                except ValueError:
+                                    cmd["source"] = str(path)
+                            processed_commands.append(cmd)
+
+                        elif hasattr(cmd, "__dict__"):  # Object with attributes
+                            if not hasattr(cmd, "file") or not cmd.file:
+                                cmd.file = str(path)
+                            if not hasattr(cmd, "source") or not cmd.source:
+                                try:
+                                    cmd.source = str(
+                                        path.relative_to(self.project_path)
+                                    )
+                                except ValueError:
+                                    cmd.source = str(path)
+                            processed_commands.append(cmd)
+
+                    except Exception as e:
+                        logger.warning(
+                            f"Error processing command from {path}: {e}",
+                            exc_info=logger.isEnabledFor(logging.DEBUG),
+                        )
 
-                commands.extend(file_commands)
-                logger.debug(f"Found {len(file_commands)} commands in {file_path}")
+                commands.extend(processed_commands)
+                logger.debug(f"Found {len(processed_commands)} commands in {path}")
 
             except Exception as e:
-                logger.error(f"Error parsing {file_path}: {e}", exc_info=True)
+                logger.error(
+                    f"Error parsing {path}: {e}",
+                    exc_info=logger.isEnabledFor(logging.DEBUG),
+                )
+
         except Exception as e:
-            logger.error(f"Unexpected error processing {file_path}: {e}", exc_info=True)
+            logger.error(
+                f"Unexpected error processing {path}: {e}",
+                exc_info=logger.isEnabledFor(logging.DEBUG),
+            )
 
         return commands
 
@@ -421,24 +481,65 @@ class ProjectCommandDetector:
 
         return result_commands
 
-    def _get_parser_for_file(self, file_path: Path) -> Optional[BaseParser]:
+    def _get_parser_for_file(self, file_path: Union[str, Path]) -> Optional[BaseParser]:
         """Get a parser for a specific file (legacy method).
 
         Args:
-            file_path: Path to the file
+            file_path: Path to the file (can be str or Path)
 
         Returns:
             Parser instance or None if no parser found
         """
+        # Ensure we have a Path object
+        path = Path(file_path) if isinstance(file_path, str) else file_path
+
+        if not path.exists():
+            logger.debug(f"File does not exist: {path}")
+            return None
+
+        logger.debug(f"Looking for parser for file: {path}")
+
         for parser in self.parsers:
             try:
-                if hasattr(parser, "can_parse") and parser.can_parse(file_path):
+                if not hasattr(parser, "can_parse"):
+                    logger.debug(
+                        f"Parser {parser.__class__.__name__} has no can_parse method"
+                    )
+                    continue
+
+                # Check if this parser can handle the file
+                can_parse = False
+                try:
+                    can_parse = parser.can_parse(path)
+                except Exception as e:
+                    logger.warning(
+                        f"Error in can_parse for {parser.__class__.__name__} on {path}: {e}",
+                        exc_info=logger.isEnabledFor(logging.DEBUG),
+                    )
+                    continue
+
+                if can_parse:
+                    logger.debug(
+                        f"Found matching parser: {parser.__class__.__name__} for {path}"
+                    )
+                    # Set the file_path on the parser if it has that attribute
+                    if hasattr(parser, "file_path"):
+                        parser.file_path = path
+                    if hasattr(parser, "project_root") and not hasattr(
+                        parser, "_project_root_set"
+                    ):
+                        parser.project_root = self.project_path
+                        parser._project_root_set = True
                     return parser
+
             except Exception as e:
                 logger.warning(
-                    f"Error checking parser {parser.__class__.__name__}: {e}"
+                    f"Error checking parser {parser.__class__.__name__} on {path}: {e}",
+                    exc_info=logger.isEnabledFor(logging.DEBUG),
                 )
+                continue
 
+        logger.debug(f"No parser found for file: {path}")
         return None
 
     def test_commands(self, commands: List) -> None:
@@ -489,11 +590,50 @@ class ProjectCommandDetector:
         Returns:
             Dictionary with command execution results
         """
+        logger.debug(f"Running command in virtualenv: {command}")
+
         # Get environment variables for virtualenv
         venv_env = self._get_environment()
+        logger.debug(f"Initial venv_env: {venv_env}")
+
+        # Ensure we have the virtual environment path in the environment
+        if self.venv_info.get("exists"):
+            if "VIRTUAL_ENV" not in venv_env:
+                venv_env["VIRTUAL_ENV"] = self.venv_info["path"]
+                logger.debug(f"Set VIRTUAL_ENV to: {venv_env['VIRTUAL_ENV']}")
+
+        # Ensure we have the Python path in the environment
+        if self.venv_info.get("python_path"):
+            if "python_path" not in venv_env:
+                venv_env["python_path"] = self.venv_info["python_path"]
+                logger.debug(f"Set python_path to: {venv_env['python_path']}")
+
+        # Ensure the virtualenv's bin/Scripts directory is in PATH
+        if self.venv_info.get("path"):
+            venv_path = Path(self.venv_info["path"])
+            bin_dir = "Scripts" if os.name == "nt" else "bin"
+            venv_bin = str(venv_path / bin_dir)
+
+            # Add to the beginning of PATH
+            path = venv_env.get("PATH", "")
+            if venv_bin not in path.split(os.pathsep):
+                venv_env["PATH"] = f"{venv_bin}{os.pathsep}{path}"
+                logger.debug(f"Updated PATH to: {venv_env['PATH']}")
+        else:
+            logger.warning("No virtual environment path found in venv_info")
 
-        # Pass the environment to command_handler.run_in_venv
-        return self.command_handler.run_in_venv(command, venv_env=venv_env, **kwargs)
+        logger.debug(f"Final environment for command execution: {venv_env}")
+
+        try:
+            # Pass the environment to command_handler.run_in_venv
+            result = self.command_handler.run_in_venv(
+                command, venv_env=venv_env, **kwargs
+            )
+            logger.debug(f"Command execution result: {result}")
+            return result
+        except Exception as e:
+            logger.error(f"Error executing command in virtualenv: {e}", exc_info=True)
+            raise
 
     def _execute_command(self, command_info: Dict[str, Any]) -> Dict[str, Any]:
         """Execute a command with the given information.