domd 2.2.1__tar.gz → 2.2.3__tar.gz

{domd-2.2.1 → domd-2.2.3}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "domd"
-version = "2.2.1"
+version = "2.2.3"
 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.1 → domd-2.2.3}/src/domd/core/project_detection/detector.py

@@ -213,6 +213,56 @@ class ProjectCommandDetector:
         """
         return get_virtualenv_environment(self.venv_info)
 
+    def _process_directory_readme(
+        self, directory: Path, all_commands: list, parent_dir: str = None
+    ) -> None:
+        """Process a README.md file in a directory and update command metadata.
+
+        Args:
+            directory: Directory containing the README.md
+            all_commands: List to append found commands to
+            parent_dir: Name of parent directory (for second-level directories)
+        """
+        logger.debug(f"Checking for README.md in: {directory}")
+        readme_path = directory / "README.md"
+
+        if not readme_path.exists():
+            logger.debug(f"  README.md not found in {directory}")
+            return
+
+        if not readme_path.is_file():
+            logger.debug(f"  README.md exists but is not a file in {directory}")
+            return
+
+        logger.info(f"Found README.md in directory: {directory}")
+
+        # Determine display path for logging and source
+        if parent_dir:
+            display_path = f"{parent_dir}/{directory.name}/README.md"
+        else:
+            display_path = f"{directory.name}/README.md"
+
+        logger.info(f"Found README.md: {display_path}")
+
+        # Process README.md in directory
+        commands = self._process_file_commands(readme_path)
+
+        # Update command metadata with directory context
+        for cmd in commands:
+            if isinstance(cmd, dict):
+                cmd_metadata = cmd.setdefault("metadata", {})
+                cmd_metadata["cwd"] = str(directory)
+                cmd_metadata["source"] = display_path
+            elif hasattr(cmd, "metadata"):
+                if not hasattr(cmd.metadata, "get") or not callable(cmd.metadata.get):
+                    cmd.metadata = {"original_metadata": cmd.metadata}
+                cmd.metadata["cwd"] = str(directory)
+                if not getattr(cmd, "source", None):
+                    cmd.source = display_path
+
+        all_commands.extend(commands)
+        logger.info(f"Found {len(commands)} commands in {display_path}")
+
     def _process_file_commands(self, file_path: Path) -> List[Dict]:
         """Process a single file and extract commands.
 
@@ -220,54 +270,41 @@ class ProjectCommandDetector:
             file_path: Path to the file to process
 
         Returns:
-            List of command dictionaries
+            List of command dictionaries with metadata
         """
+        logger.debug(f"Processing file: {file_path}")
         commands = []
-        try:
-            # Try to get parser from registry first
-            parser = self.parser_registry.get_parser_for_file(file_path)
-
-            # If no parser found in registry, try legacy method
-            if not parser:
-                parser = self._get_parser_for_file(file_path)
 
-            if not parser:
-                logger.warning(f"No parser found for {file_path}")
+        try:
+            if not file_path.exists():
+                logger.warning(f"File not found: {file_path}")
                 return commands
 
-            logger.debug(f"Parsing {file_path} with {parser.__class__.__name__}")
-
-            # Read file content
-            try:
-                with open(file_path, "r", encoding="utf-8") as f:
-                    content = f.read()
-            except Exception as e:
-                logger.error(f"Error reading file {file_path}: {e}")
+            # Get the appropriate parser for the file
+            parser = self._get_parser_for_file(file_path)
+            if not parser:
+                logger.debug(f"No parser found for file: {file_path}")
                 return commands
 
-            # Set the file_path on the parser if it has that attribute
-            if hasattr(parser, "file_path"):
-                parser.file_path = file_path
-
-            # Try different ways to call the parse method
             try:
-                import inspect
-
-                sig = inspect.signature(parser.parse)
-
-                if "file_path" in sig.parameters and "content" in sig.parameters:
-                    file_commands = parser.parse(content=content, file_path=file_path)
-                elif "content" in sig.parameters:
-                    file_commands = parser.parse(content=content)
-                elif "file_path" in sig.parameters:
-                    file_commands = parser.parse(file_path=file_path)
-                else:
-                    # Last resort - try passing content as the first argument
-                    file_commands = parser.parse(content)
+                # Read file content
+                content = file_path.read_text(encoding="utf-8")
+
+                # Parse commands from file content
+                file_commands = []
+                if hasattr(parser, "parse_file") and callable(parser.parse_file):
+                    file_commands = parser.parse_file(file_path)
+                elif hasattr(parser, "parse") and callable(parser.parse):
+                    # Try with content as string
+                    try:
+                        file_commands = parser.parse(content)
+                    except TypeError:
+                        # Last resort - try passing content as the first argument
+                        file_commands = parser.parse(content)
 
                 # Add file path to commands if not already present
                 for cmd in file_commands:
-                    if isinstance(cmd, dict) and "file" not in cmd:
+                    if isinstance(cmd, dict):
                         cmd["file"] = str(file_path)
                         # Add relative path as source if not present
                         if "source" not in cmd:
@@ -309,37 +346,47 @@ class ProjectCommandDetector:
         for file_path in config_files:
             all_commands.extend(self._process_file_commands(file_path))
 
-        # 2. Scan first-level subdirectories for README.md files
+        # 2. Scan first and second level subdirectories for README.md files
         try:
-            for item in self.project_path.iterdir():
-                if item.is_dir() and not item.name.startswith("."):
-                    readme_path = item / "README.md"
-                    if readme_path.exists() and readme_path.is_file():
-                        logger.info(f"Found README.md in subdirectory: {item.name}")
-                        # Process README.md in subdirectory
-                        commands = self._process_file_commands(readme_path)
-
-                        # Update command metadata with subdirectory context
-                        for cmd in commands:
-                            if isinstance(cmd, dict):
-                                cmd_metadata = cmd.setdefault("metadata", {})
-                                cmd_metadata["cwd"] = str(item)
-                                cmd_metadata["source"] = f"{item.name}/README.md"
-                            elif hasattr(cmd, "metadata"):
-                                if not hasattr(cmd.metadata, "get") or not callable(
-                                    cmd.metadata.get
-                                ):
-                                    cmd.metadata = {"original_metadata": cmd.metadata}
-                                cmd.metadata["cwd"] = str(item)
-                                if not getattr(cmd, "source", None):
-                                    cmd.source = f"{item.name}/README.md"
-
-                        all_commands.extend(commands)
+            logger.debug(f"Starting directory scan in: {self.project_path}")
+            # First level directories
+            for level1_item in sorted(self.project_path.iterdir()):
+                logger.debug(f"Checking first level item: {level1_item}")
+                if not level1_item.is_dir() or level1_item.name.startswith("."):
+                    logger.debug(f"Skipping (not a directory or hidden): {level1_item}")
+                    continue
+
+                logger.info(f"Processing first level directory: {level1_item.name}")
+                # Process level 1 README
+                self._process_directory_readme(level1_item, all_commands)
+
+                # Scan second level
+                try:
+                    for level2_item in sorted(level1_item.iterdir()):
+                        logger.debug(f"  Checking second level item: {level2_item}")
+                        if not level2_item.is_dir() or level2_item.name.startswith("."):
+                            logger.debug(
+                                f"  Skipping (not a directory or hidden): {level2_item}"
+                            )
+                            continue
+
                         logger.info(
-                            f"Found {len(commands)} commands in {item.name}/README.md"
+                            f"  Processing second level directory: {level1_item.name}/{level2_item.name}"
                         )
+                        # Process level 2 README
+                        self._process_directory_readme(
+                            level2_item, all_commands, level1_item.name
+                        )
+                except Exception as e:
+                    logger.error(
+                        f"Error scanning subdirectory {level1_item}: {e}", exc_info=True
+                    )
         except Exception as e:
-            logger.error(f"Error scanning subdirectories: {e}", exc_info=True)
+            logger.error(f"Error scanning directories: {e}", exc_info=True)
+
+        logger.debug(
+            f"Finished directory scan. Found {len(all_commands)} commands total."
+        )
 
         logger.info(f"Found {len(all_commands)} commands in total")
 
@@ -654,9 +701,7 @@ class ProjectCommandDetector:
                         source = cmd_dict.get("source", "Unknown")
 
                         f.write(f"### 🔧 Fix: {command}\n")  # noqa: E231
-                        f.write(
-                            f"- [ ] **Command**: `{command}`  \n"
-                        )  # noqa: E201,E231
+                        f.write(f"- [ ] **Command**: `{command}`  \n")  # noqa: E201,E231
                         f.write(f"- **Error**: {error}  \n")  # noqa: E231
                         f.write(f"- **Source**: `{source}`\n")  # noqa: E231
                         f.write("- **Fix Suggestion**: \n\n")  # noqa: E231