crackerjack 0.37.7__py3-none-any.whl → 0.37.9__py3-none-any.whl

crackerjack/core/workflow_orchestrator.py

@@ -67,10 +67,8 @@ class WorkflowPipeline:
 
         # Initialize quality intelligence for advanced decision making
         try:
-            quality_baseline = EnhancedQualityBaselineService(console, pkg_path)
-            self._quality_intelligence = QualityIntelligenceService(
-                quality_baseline, console
-            )
+            quality_baseline = EnhancedQualityBaselineService()
+            self._quality_intelligence = QualityIntelligenceService(quality_baseline)
         except Exception:
             # Fallback gracefully if quality intelligence is not available
             self._quality_intelligence = None
@@ -418,11 +416,11 @@ class WorkflowPipeline:
             success = success and config_success
 
         quality_success = await self._execute_quality_phase(options, workflow_id)
-        if not quality_success:
-            success = False
+        success = success and quality_success
 
-            if self._is_publishing_workflow(options):
-                return False
+        # If quality phase failed and we're in publishing mode, stop here
+        if not quality_success and self._is_publishing_workflow(options):
+            return False
 
         # Execute publishing workflow if requested
         publishing_success = await self._execute_publishing_workflow(
@@ -447,6 +445,30 @@ class WorkflowPipeline:
 
         return success
 
+    def _handle_quality_phase_result(
+        self, success: bool, quality_success: bool, options: OptionsProtocol
+    ) -> bool:
+        """Handle the result of the quality phase execution."""
+        if not quality_success:
+            if self._is_publishing_workflow(options):
+                # For publishing workflows, quality failures should stop execution
+                return False
+            # For non-publishing workflows, we continue but mark as failed
+            return False
+        return success
+
+    def _handle_workflow_completion(
+        self, success: bool, publishing_success: bool, options: OptionsProtocol
+    ) -> bool:
+        """Handle workflow completion and determine final success status."""
+        # Only fail the overall workflow if publishing was explicitly requested and failed
+        if not publishing_success and (options.publish or options.all):
+            self.console.print(
+                "[red]❌ Publishing failed - overall workflow marked as failed[/red]"
+            )
+            return False
+        return success
+
     def _is_publishing_workflow(self, options: OptionsProtocol) -> bool:
         return bool(options.publish or options.all)
 
@@ -504,14 +526,14 @@ class WorkflowPipeline:
                 return "Quality intelligence not available"
 
             # Analyze recent quality trends and anomalies
-            anomalies = await self._quality_intelligence.detect_anomalies()
-            patterns = await self._quality_intelligence.identify_patterns()
+            anomalies = self._quality_intelligence.detect_anomalies()
+            patterns = self._quality_intelligence.identify_patterns()
 
             # Make intelligent recommendations based on current state
             recommendations = []
             if anomalies:
                 high_severity_anomalies = [
-                    a for a in anomalies if a.severity.name in ["CRITICAL", "HIGH"]
+                    a for a in anomalies if a.severity.name in ("CRITICAL", "HIGH")
                 ]
                 if high_severity_anomalies:
                     recommendations.append(

crackerjack/documentation/reference_generator.py

@@ -397,13 +397,29 @@ class ReferenceGenerator:
 
         arg_index = func_node.args.args.index(arg)
         if arg_index >= defaults_start:
-            default_index = arg_index - defaults_start
-            default_node = func_node.args.defaults[default_index]
-            if isinstance(default_node, ast.Constant):
-                return default_node.value, False
+            return self._extract_argument_default(arg_index, defaults_start, func_node)
 
         return None, True
 
+    def _extract_argument_default(
+        self, arg_index: int, defaults_start: int, func_node: ast.FunctionDef
+    ) -> tuple[t.Any, bool]:
+        """Extract default value for a specific argument.
+
+        Args:
+            arg_index: Index of the argument
+            defaults_start: Index where defaults start
+            func_node: Parent function node
+
+        Returns:
+            Tuple of (default_value, required)
+        """
+        default_index = arg_index - defaults_start
+        default_node = func_node.args.defaults[default_index]
+        if isinstance(default_node, ast.Constant):
+            return default_node.value, False
+        return None, True
+
     async def _enhance_with_examples(
         self, commands: dict[str, CommandInfo]
     ) -> dict[str, CommandInfo]:
@@ -416,35 +432,47 @@ class ReferenceGenerator:
             Enhanced commands with examples
         """
         for command in commands.values():
-            # Generate basic examples
-            basic_example = f"python -m crackerjack --{command.name}"
-
-            # Add parameter examples
-            param_examples = []
-            for param in command.parameters:
-                if not param.required and param.default_value is not None:
-                    if isinstance(param.default_value, bool):
-                        param_examples.append(f"--{param.name}")
-                    else:
-                        param_examples.append(f"--{param.name} {param.default_value}")
-
-            if param_examples:
-                enhanced_example = f"{basic_example} {' '.join(param_examples)}"
-                command.examples.append(
-                    {
-                        "description": f"Using {command.name} with parameters",
-                        "command": enhanced_example,
-                    }
-                )
+            self._add_basic_example(command)
+            self._add_parameter_examples(command)
+        return commands
+
+    def _add_basic_example(self, command: CommandInfo) -> None:
+        """Add a basic example for a command."""
+        basic_example = f"python -m crackerjack --{command.name}"
+        command.examples.append(
+            {
+                "description": f"Basic {command.name} usage",
+                "command": basic_example,
+            }
+        )
 
+    def _add_parameter_examples(self, command: CommandInfo) -> None:
+        """Add parameter examples for a command."""
+        # Generate basic examples
+        basic_example = f"python -m crackerjack --{command.name}"
+
+        # Add parameter examples
+        param_examples = []
+        for param in command.parameters:
+            if not param.required and param.default_value is not None:
+                param_example = self._format_parameter_example(param)
+                if param_example:
+                    param_examples.append(param_example)
+
+        if param_examples:
+            enhanced_example = f"{basic_example} {' '.join(param_examples)}"
             command.examples.append(
                 {
-                    "description": f"Basic {command.name} usage",
-                    "command": basic_example,
+                    "description": f"Using {command.name} with parameters",
+                    "command": enhanced_example,
                 }
             )
 
-        return commands
+    def _format_parameter_example(self, param: ParameterInfo) -> str | None:
+        """Format a parameter example."""
+        if isinstance(param.default_value, bool):
+            return f"--{param.name}"
+        return f"--{param.name} {param.default_value}"
 
     async def _enhance_with_workflows(
         self, commands: dict[str, CommandInfo]
@@ -632,26 +660,26 @@ class ReferenceGenerator:
         ]
 
     def _render_markdown_categories(self, reference: CommandReference) -> list[str]:
-        """Render command categories for markdown.
-
-        Args:
-            reference: Command reference
-
-        Returns:
-            List of category section lines
-        """
+        """Render command categories for markdown."""
         category_lines = []
         for category, command_names in reference.categories.items():
-            category_lines.extend(
-                [
-                    f"## {category.title()}",
-                    "",
-                ]
-            )
+            category_section = self._render_markdown_category(category, reference.commands, command_names)
+            category_lines.extend(category_section)
+        return category_lines
 
-            for command_name in command_names:
-                command = reference.commands[command_name]
-                category_lines.extend(self._render_command_markdown(command))
+    def _render_markdown_category(
+        self, category: str, commands: dict[str, CommandInfo], command_names: list[str]
+    ) -> list[str]:
+        """Render markdown for a single category."""
+        category_lines = [
+            f"## {category.title()}",
+            "",
+        ]
+
+        for command_name in command_names:
+            command = commands[command_name]
+            command_lines = self._render_command_markdown(command)
+            category_lines.extend(command_lines)
 
         return category_lines
 
@@ -685,14 +713,7 @@ class ReferenceGenerator:
         return workflow_lines
 
     def _render_command_markdown(self, command: CommandInfo) -> list[str]:
-        """Render single command as Markdown.
-
-        Args:
-            command: Command to render
-
-        Returns:
-            List of markdown lines
-        """
+        """Render single command as Markdown."""
         lines = [
             f"### `{command.name}`",
             "",
@@ -702,50 +723,47 @@ class ReferenceGenerator:
 
         # Add parameters section
         if command.parameters:
-            lines.extend(self._render_command_parameters_markdown(command.parameters))
+            param_lines = self._render_command_parameters_markdown(command.parameters)
+            lines.extend(param_lines)
 
         # Add examples section
         if command.examples:
-            lines.extend(self._render_command_examples_markdown(command.examples))
+            example_lines = self._render_command_examples_markdown(command.examples)
+            lines.extend(example_lines)
 
         # Add related commands section
         if command.related_commands:
-            lines.extend(
-                self._render_command_related_markdown(command.related_commands)
-            )
+            related_lines = self._render_command_related_markdown(command.related_commands)
+            lines.extend(related_lines)
 
         return lines
 
     def _render_command_parameters_markdown(
         self, parameters: list[ParameterInfo]
     ) -> list[str]:
-        """Render command parameters for markdown.
-
-        Args:
-            parameters: List of parameters to render
-
-        Returns:
-            List of parameter section lines
-        """
+        """Render command parameters for markdown."""
         param_lines = [
             "**Parameters:**",
             "",
         ]
 
         for param in parameters:
-            required_str = " (required)" if param.required else ""
-            default_str = (
-                f" (default: {param.default_value})"
-                if param.default_value is not None
-                else ""
-            )
-            param_lines.append(
-                f"- `--{param.name}` ({param.type_hint}){required_str}{default_str}: {param.description}"
-            )
+            param_line = self._format_parameter_line(param)
+            param_lines.append(param_line)
 
         param_lines.append("")
         return param_lines
 
+    def _format_parameter_line(self, param: ParameterInfo) -> str:
+        """Format a single parameter line."""
+        required_str = " (required)" if param.required else ""
+        default_str = (
+            f" (default: {param.default_value})"
+            if param.default_value is not None
+            else ""
+        )
+        return f"- `--{param.name}` ({param.type_hint}){required_str}{default_str}: {param.description}"
+
     def _render_command_examples_markdown(
         self, examples: list[dict[str, str]]
     ) -> list[str]:
@@ -794,12 +812,12 @@ class ReferenceGenerator:
 
     def _render_html(self, reference: CommandReference) -> str:
         """Render reference as HTML."""
-        html = self._render_html_header(
-            reference.generated_at.strftime("%Y-%m-%d %H:%M:%S")
-        )
-        html += self._render_html_commands(reference)
-        html += "</body></html>"
-        return html
+        html_parts = [
+            self._render_html_header(reference.generated_at.strftime("%Y-%m-%d %H:%M:%S")),
+            self._render_html_commands(reference),
+            "</body></html>"
+        ]
+        return "".join(html_parts)
 
     def _render_html_header(self, generated_at: str) -> str:
         """Render HTML header with styles and metadata."""
@@ -822,26 +840,38 @@ class ReferenceGenerator:
 
     def _render_html_commands(self, reference: CommandReference) -> str:
         """Render HTML commands by category."""
-        html = ""
+        html_parts = []
         for category, command_names in reference.categories.items():
-            html += f"<h2>{category.title()}</h2>"
-            html += self._render_html_category_commands(
-                reference.commands, command_names
-            )
+            category_html = self._render_html_category(category, reference.commands, command_names)
+            html_parts.append(category_html)
+        return "".join(html_parts)
+
+    def _render_html_category(
+        self, category: str, commands: dict[str, CommandInfo], command_names: list[str]
+    ) -> str:
+        """Render HTML for a single category."""
+        html = f"<h2>{category.title()}</h2>"
+        html += self._render_html_category_commands(commands, command_names)
         return html
 
     def _render_html_category_commands(
         self, commands: dict[str, CommandInfo], command_names: list[str]
     ) -> str:
         """Render HTML for commands in a category."""
-        html = ""
+        html_parts = []
         for command_name in command_names:
             command = commands[command_name]
-            html += '<div class="command">'
-            html += f"<h3><code>{command.name}</code></h3>"
-            html += f"<p>{command.description}</p>"
-            html += self._render_html_command_parameters(command.parameters)
-            html += "</div>"
+            command_html = self._render_single_html_command(command)
+            html_parts.append(command_html)
+        return "".join(html_parts)
+
+    def _render_single_html_command(self, command: CommandInfo) -> str:
+        """Render HTML for a single command."""
+        html = '<div class="command">'
+        html += f"<h3><code>{command.name}</code></h3>"
+        html += f"<p>{command.description}</p>"
+        html += self._render_html_command_parameters(command.parameters)
+        html += "</div>"
         return html
 
     def _render_html_command_parameters(self, parameters: list[ParameterInfo]) -> str:
@@ -864,31 +894,44 @@ class ReferenceGenerator:
             "version": reference.version,
             "categories": reference.categories,
             "workflows": reference.workflows,
-            "commands": {},
+            "commands": self._serialize_commands(reference.commands),
         }
 
-        for name, command in reference.commands.items():
-            data["commands"][name] = {
-                "name": command.name,
-                "description": command.description,
-                "category": command.category,
-                "parameters": [
-                    {
-                        "name": param.name,
-                        "type": param.type_hint,
-                        "default": param.default_value,
-                        "description": param.description,
-                        "required": param.required,
-                    }
-                    for param in command.parameters
-                ],
-                "examples": command.examples,
-                "related_commands": command.related_commands,
-                "aliases": command.aliases,
-            }
-
         return json.dumps(data, indent=2, default=str)
 
+    def _serialize_commands(self, commands: dict[str, CommandInfo]) -> dict[str, t.Any]:
+        """Serialize commands for JSON output."""
+        serialized_commands = {}
+        for name, command in commands.items():
+            serialized_commands[name] = self._serialize_command(command)
+        return serialized_commands
+
+    def _serialize_command(self, command: CommandInfo) -> dict[str, t.Any]:
+        """Serialize a single command for JSON output."""
+        return {
+            "name": command.name,
+            "description": command.description,
+            "category": command.category,
+            "parameters": self._serialize_parameters(command.parameters),
+            "examples": command.examples,
+            "related_commands": command.related_commands,
+            "aliases": command.aliases,
+        }
+
+    def _serialize_parameters(self, parameters: list[ParameterInfo]) -> list[dict[str, t.Any]]:
+        """Serialize parameters for JSON output."""
+        return [self._serialize_parameter(param) for param in parameters]
+
+    def _serialize_parameter(self, param: ParameterInfo) -> dict[str, t.Any]:
+        """Serialize a single parameter for JSON output."""
+        return {
+            "name": param.name,
+            "type": param.type_hint,
+            "default": param.default_value,
+            "description": param.description,
+            "required": param.required,
+        }
+
     def _render_yaml(self, reference: CommandReference) -> str:
         """Render reference as YAML."""
         import yaml

crackerjack/dynamic_config.py

@@ -1,5 +1,6 @@
 import tempfile
 import typing as t
+from contextlib import suppress
 from pathlib import Path
 
 import jinja2
@@ -459,33 +460,36 @@ PRE_COMMIT_TEMPLATE = """repos:
 class DynamicConfigGenerator:
     def __init__(self, package_directory: str | None = None) -> None:
         self.template = jinja2.Template(PRE_COMMIT_TEMPLATE)
-        self.package_directory = package_directory or self._detect_package_directory()
+        self.package_directory = self._sanitize_package_directory(
+            package_directory or self._detect_package_directory()
+        )
+
+    def _sanitize_package_directory(self, package_directory: str) -> str:
+        """Convert hyphens to underscores in package directory names."""
+        return package_directory.replace("-", "_")
 
     def _detect_package_directory(self) -> str:
         """Detect the package directory name for the current project."""
-        import os
         from pathlib import Path
 
         # Check if we're in the crackerjack project itself
-        current_dir = Path(os.getcwd())
+        current_dir = Path.cwd()
         if (current_dir / "crackerjack").exists() and (
             current_dir / "pyproject.toml"
         ).exists():
             # Check if this is actually the crackerjack project
-            try:
+            with suppress(Exception):
                 import tomllib
 
                 with (current_dir / "pyproject.toml").open("rb") as f:
                     data = tomllib.load(f)
                 if data.get("project", {}).get("name") == "crackerjack":
                     return "crackerjack"
-            except Exception:
-                pass
 
         # Try to read package name from pyproject.toml
         pyproject_path = current_dir / "pyproject.toml"
         if pyproject_path.exists():
-            try:
+            with suppress(Exception):
                 import tomllib
 
                 with pyproject_path.open("rb") as f:
@@ -496,8 +500,6 @@ class DynamicConfigGenerator:
                     # Check if package directory exists
                     if (current_dir / package_name).exists():
                         return package_name
-            except Exception:
-                pass
 
         # Fallback to project directory name
         if (current_dir / current_dir.name).exists():

crackerjack/hooks/lsp_hook.py

@@ -23,9 +23,7 @@ def main() -> int:
 
     # If no files specified, check project files
     if not files_to_check:
-        project_path = Path.cwd()
-        lsp_client = LSPClient(console)
-        files_to_check = lsp_client.get_project_files(project_path)
+        files_to_check = _get_project_files(console)
 
     if not files_to_check:
         console.print("🔍 No Python files to check")
@@ -36,29 +34,46 @@ def main() -> int:
 
     # Check if LSP server is running
     if not lsp_client.is_server_running():
-        console.print(
-            "⚠️  Zuban LSP server not running, falling back to direct zuban check"
-        )
-        # Fall back to regular zuban execution
-        import subprocess
-
-        try:
-            result = subprocess.run(
-                ["zuban", "check"] + files_to_check,
-                capture_output=True,
-                text=True,
-                timeout=120,
-            )
-            if result.stdout:
-                console.print(result.stdout)
-            if result.stderr:
-                console.print(result.stderr, style="red")
-            return result.returncode
-        except (subprocess.TimeoutExpired, FileNotFoundError) as e:
-            console.print(f"❌ Error running zuban: {e}", style="red")
-            return 1
+        return _fallback_to_zuban_check(console, files_to_check)
 
     # Use LSP server for type checking
+    return _check_files_with_lsp(console, lsp_client, files_to_check)
+
+
+def _get_project_files(console: Console) -> list[str]:
+    """Get project files to check."""
+    project_path = Path.cwd()
+    lsp_client = LSPClient(console)
+    return lsp_client.get_project_files(project_path)
+
+
+def _fallback_to_zuban_check(console: Console, files_to_check: list[str]) -> int:
+    """Fall back to regular zuban execution when LSP server is not running."""
+    console.print("⚠️  Zuban LSP server not running, falling back to direct zuban check")
+    # Fall back to regular zuban execution
+    import subprocess
+
+    try:
+        result = subprocess.run(
+            ["zuban", "check"] + files_to_check,
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        if result.stdout:
+            console.print(result.stdout)
+        if result.stderr:
+            console.print(result.stderr, style="red")
+        return result.returncode
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        console.print(f"❌ Error running zuban: {e}", style="red")
+        return 1
+
+
+def _check_files_with_lsp(
+    console: Console, lsp_client: LSPClient, files_to_check: list[str]
+) -> int:
+    """Check files using LSP server."""
     server_info = lsp_client.get_server_info()
     if server_info:
         console.print(f"🔍 Using Zuban LSP server (PID: {server_info['pid']})")

crackerjack/interactive.py

@@ -37,23 +37,12 @@ class WorkflowOptions:
     @classmethod
     def from_args(cls, args: t.Any) -> "WorkflowOptions":
         return cls(
-            cleaning=CleaningConfig(
-                clean=getattr(args, "clean", False),
-            ),
-            testing=TestConfig(
-                test=getattr(args, "test", False),
-            ),
-            publishing=PublishConfig(
-                publish=getattr(args, "publish", None),
-                bump=getattr(args, "bump", None),
-            ),
-            git=GitConfig(
-                commit=getattr(args, "commit", False),
-                create_pr=getattr(args, "create_pr", False),
-            ),
-            ai=AIConfig(
-                ai_agent=getattr(args, "ai_agent", False),
-            ),
+            clean=getattr(args, "clean", False),
+            test=getattr(args, "test", False),
+            publish=getattr(args, "publish", None),
+            bump=getattr(args, "bump", None),
+            commit=getattr(args, "commit", False),
+            create_pr=getattr(args, "create_pr", False),
             interactive=getattr(args, "interactive", True),
             dry_run=getattr(args, "dry_run", False),
         )

crackerjack/managers/publish_manager.py

@@ -124,7 +124,7 @@ class PublishManagerImpl:
 
         # Get intelligent version analysis and recommendation
         recommendation = self._get_version_recommendation()
-        if recommendation and version_type not in ["interactive"]:
+        if recommendation and version_type != "interactive":
             self._display_version_analysis(recommendation)
             if version_type == "auto":
                 version_type = recommendation.bump_type.value

crackerjack/mcp/tools/execution_tools_backup.py

@@ -812,24 +812,23 @@ def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
         t.cast(list[str], suggestions["usage_patterns"])
 
         if project_type.lower() == "python" or "python" in task_description.lower():
-            primary_agents.append(
-                {
-                    "name": "crackerjack-architect",
-                    "emoji": "🏗️",
-                    "description": "Expert in crackerjack's modular architecture and Python project management patterns",
-                    "usage": "Use PROACTIVELY for all feature development, architectural decisions, and ensuring code follows crackerjack standards",
-                    "priority": "HIGH",
-                }
-            )
-
-            primary_agents.append(
-                {
-                    "name": "python-pro",
-                    "emoji": "🐍",
-                    "description": "Modern Python development with type hints, async/await patterns, and clean architecture",
-                    "usage": "Use for implementing Python code with best practices",
-                    "priority": "HIGH",
-                }
+            primary_agents.extend(
+                (
+                    {
+                        "name": "crackerjack-architect",
+                        "emoji": "🏗️",
+                        "description": "Expert in crackerjack's modular architecture and Python project management patterns",
+                        "usage": "Use PROACTIVELY for all feature development, architectural decisions, and ensuring code follows crackerjack standards",
+                        "priority": "HIGH",
+                    },
+                    {
+                        "name": "python-pro",
+                        "emoji": "🐍",
+                        "description": "Modern Python development with type hints, async/await patterns, and clean architecture",
+                        "usage": "Use for implementing Python code with best practices",
+                        "priority": "HIGH",
+                    },
+                )
             )
 
         task_lower = task_description.lower()
@@ -839,24 +838,23 @@ def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
             word in task_lower + context_lower
             for word in ("test", "testing", "coverage", "pytest")
         ):
-            task_specific_agents.append(
-                {
-                    "name": "crackerjack-test-specialist",
-                    "emoji": "🧪",
-                    "description": "Advanced testing specialist for complex scenarios and coverage optimization",
-                    "usage": "Use for test creation, debugging test failures, and coverage improvements",
-                    "priority": "HIGH",
-                }
-            )
-
-            task_specific_agents.append(
-                {
-                    "name": "pytest-hypothesis-specialist",
-                    "emoji": "🧪",
-                    "description": "Advanced testing patterns and property-based testing",
-                    "usage": "Use for comprehensive test development and optimization",
-                    "priority": "MEDIUM",
-                }
+            task_specific_agents.extend(
+                (
+                    {
+                        "name": "crackerjack-test-specialist",
+                        "emoji": "🧪",
+                        "description": "Advanced testing specialist for complex scenarios and coverage optimization",
+                        "usage": "Use for test creation, debugging test failures, and coverage improvements",
+                        "priority": "HIGH",
+                    },
+                    {
+                        "name": "pytest-hypothesis-specialist",
+                        "emoji": "🧪",
+                        "description": "Advanced testing patterns and property-based testing",
+                        "usage": "Use for comprehensive test development and optimization",
+                        "priority": "MEDIUM",
+                    },
+                )
             )
 
         if any(

crackerjack/services/config.py

@@ -12,8 +12,10 @@ class ConfigurationService:
     def __init__(self, console: Console, pkg_path: Path) -> None:
         self.console = console
         self.pkg_path = pkg_path
-        # Extract package directory name from the pkg_path
+        # Extract package directory name from the pkg_path and sanitize it
         package_directory = pkg_path.name if pkg_path != Path.cwd() else None
+        if package_directory:
+            package_directory = package_directory.replace("-", "_")
         self.config_generator = DynamicConfigGenerator(package_directory)
 
     def update_precommit_config(self, options: OptionsProtocol) -> bool:

crackerjack/services/config_merge.py

@@ -310,7 +310,7 @@ class ConfigMergeService(ConfigMergeServiceProtocol):
             sort_keys=False,
             width=float("inf"),
         )
-        content = yaml_content or ""
+        content = yaml_content
 
         from crackerjack.services.filesystem import FileSystemService
 
@@ -506,35 +506,38 @@ class ConfigMergeService(ConfigMergeServiceProtocol):
         processed_repos = []
         for repo in repos:
             processed_repo = copy.deepcopy(repo)
-
-            # Process hooks within each repo
-            hooks = processed_repo.get("hooks", [])
-            for hook in hooks:
-                if isinstance(hook, dict):
-                    # Replace crackerjack directory references in args
-                    if "args" in hook:
-                        hook["args"] = [
-                            arg.replace("crackerjack", project_name)
-                            if isinstance(arg, str)
-                            else arg
-                            for arg in hook["args"]
-                        ]
-
-                    # Replace crackerjack directory references in files pattern
-                    if "files" in hook:
-                        files_pattern = hook["files"]
-                        if isinstance(files_pattern, str):
-                            hook["files"] = files_pattern.replace(
-                                "^crackerjack/", f"^{project_name}/"
-                            )
-
-                    # Special handling for validate-regex-patterns hook - keep it pointing to crackerjack package
-                    if hook.get("id") == "validate-regex-patterns":
-                        # This should reference the installed crackerjack package, not the current project
-                        # The entry already uses "uv run python -m crackerjack.tools.validate_regex_patterns"
-                        # which is correct - it runs from the installed crackerjack package
-                        pass
-
+            self._process_repo_hooks(processed_repo, project_name)
             processed_repos.append(processed_repo)
 
         return processed_repos
+
+    def _process_repo_hooks(self, repo: dict[str, t.Any], project_name: str) -> None:
+        """Process hooks within a repo to replace project-specific references."""
+        hooks = repo.get("hooks", [])
+        for hook in hooks:
+            if isinstance(hook, dict):
+                self._process_hook_args(hook, project_name)
+                self._process_hook_files(hook, project_name)
+                # Special handling for validate-regex-patterns hook - keep it pointing to crackerjack package
+                # This should reference the installed crackerjack package, not the current project
+                # The entry already uses "uv run python -m crackerjack.tools.validate_regex_patterns"
+                # which is correct - it runs from the installed crackerjack package
+
+    def _process_hook_args(self, hook: dict[str, t.Any], project_name: str) -> None:
+        """Process hook args to replace project-specific references."""
+        if "args" in hook:
+            hook["args"] = [
+                arg.replace("crackerjack", project_name)
+                if isinstance(arg, str)
+                else arg
+                for arg in hook["args"]
+            ]
+
+    def _process_hook_files(self, hook: dict[str, t.Any], project_name: str) -> None:
+        """Process hook files pattern to replace project-specific references."""
+        if "files" in hook:
+            files_pattern = hook["files"]
+            if isinstance(files_pattern, str):
+                hook["files"] = files_pattern.replace(
+                    "^crackerjack/", f"^{project_name}/"
+                )

crackerjack/services/secure_subprocess.py

@@ -329,36 +329,54 @@ class SecureSubprocessExecutor:
         self, arg: str, index: int, issues: list[str], command: list[str]
     ) -> bool:
         # First check if this is an allowed git pattern
-        for git_pattern in self.allowed_git_patterns:
-            if re.match(git_pattern, arg):
-                return False  # It's an allowed git pattern, don't flag as dangerous
+        if self._is_allowed_git_pattern(arg):
+            return False
 
         # Special handling for git commit messages
         if self._is_git_commit_message(index, command):
-            # For git commit messages, only check for truly dangerous patterns
-            # Parentheses are common in commit messages and should be allowed
-            safe_commit_patterns = [
-                r"[;&|`$]",  # Still dangerous in commit messages
-                r"\.\./",  # Path traversal
-                r"\$\{.*\}",  # Variable expansion
-                r"`.*`",  # Command substitution
-                r"\$\(.*\)",  # Command substitution (but allow simple parentheses)
-                r">\s*/",  # Redirection to paths
-                r"<\s*/",  # Redirection from paths
-            ]
-
-            for pattern in safe_commit_patterns:
-                if re.search(pattern, arg):
-                    # Allow simple parentheses that don't look like command substitution
-                    if pattern == r"\$\(.*\)" and not re.search(r"\$\(", arg):
-                        continue
-                    issues.append(
-                        f"Dangerous pattern '{pattern}' in argument {index}: {arg[:50]}"
-                    )
-                    return True
-            return False
+            return self._check_dangerous_patterns_in_commit_message(arg, index, issues)
 
         # Check for dangerous patterns in other contexts
+        return self._check_dangerous_patterns_in_other_contexts(arg, index, issues)
+
+    def _is_allowed_git_pattern(self, arg: str) -> bool:
+        """Check if the argument matches an allowed git pattern."""
+        for git_pattern in self.allowed_git_patterns:
+            if re.match(git_pattern, arg):
+                return True
+        return False
+
+    def _check_dangerous_patterns_in_commit_message(
+        self, arg: str, index: int, issues: list[str]
+    ) -> bool:
+        """Check for dangerous patterns specifically in git commit messages."""
+        # For git commit messages, only check for truly dangerous patterns
+        # Parentheses are common in commit messages and should be allowed
+        safe_commit_patterns = [
+            r"[;&|`$]",  # Still dangerous in commit messages
+            r"\.\./",  # Path traversal
+            r"\$\{.*\}",  # Variable expansion
+            r"`.*`",  # Command substitution
+            r"\$\(.*\)",  # Command substitution (but allow simple parentheses)
+            r">\s*/",  # Redirection to paths
+            r"<\s*/",  # Redirection from paths
+        ]
+
+        for pattern in safe_commit_patterns:
+            if re.search(pattern, arg):
+                # Allow simple parentheses that don't look like command substitution
+                if pattern == r"\$\(.*\)" and not re.search(r"\$\(", arg):
+                    continue
+                issues.append(
+                    f"Dangerous pattern '{pattern}' in argument {index}: {arg[:50]}"
+                )
+                return True
+        return False
+
+    def _check_dangerous_patterns_in_other_contexts(
+        self, arg: str, index: int, issues: list[str]
+    ) -> bool:
+        """Check for dangerous patterns in non-commit message contexts."""
         for pattern in self.dangerous_patterns:
             if re.search(pattern, arg):
                 issues.append(

crackerjack/tools/validate_regex_patterns.py

@@ -37,6 +37,7 @@ ALLOWED_PATTERNS = {
     r"crackerjack/intelligence/agent_selector\.py$",
     r"crackerjack/managers/test_.*\.py$",
     r"crackerjack/core/async_workflow_orchestrator\.py$",
+    r"crackerjack/core/workflow_orchestrator\.py$",
     r"crackerjack/agents/.*\.py$",
 }
 

{crackerjack-0.37.7.dist-info → crackerjack-0.37.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.37.7
+Version: 0.37.9
 Summary: Crackerjack Python project management tool
 Project-URL: documentation, https://github.com/lesleslie/crackerjack
 Project-URL: homepage, https://github.com/lesleslie/crackerjack

{crackerjack-0.37.7.dist-info → crackerjack-0.37.9.dist-info}/RECORD

@@ -2,9 +2,9 @@ crackerjack/__init__.py,sha256=k8_Ev_3fWdjFtGNSJdSOvyaSLW54y3j484d3a8k_Ob4,1396
 crackerjack/__main__.py,sha256=lE5ZDbAzI9TLCzMTxFGw23Dk1hP-MEhd1i_nNbi_Mag,52515
 crackerjack/api.py,sha256=sfKzCphsTMFCvdNizviPdYemwg0H8Oei_5C08LAuDvA,21538
 crackerjack/code_cleaner.py,sha256=M1zVaq31uW0nOkPneKR8kfR3892gyyVx0VhFgRaxsj4,44338
-crackerjack/dynamic_config.py,sha256=YGlUyTEp_K9rGWtLsboXMtVeKyI7bUoNoftO3ZnCiwc,21815
+crackerjack/dynamic_config.py,sha256=nwHVFCf84mokfzXhMo91-DD1ecEB6tXIgGBg0836auU,22017
 crackerjack/errors.py,sha256=yYbZ92kn_y6acEWgQvEPvozAYs2HT65uLwAXrtXxGsE,10049
-crackerjack/interactive.py,sha256=QXFZrnbY0nc8rFJcivFAVFNgUTHXqLCu3FFv5bmq_eI,21634
+crackerjack/interactive.py,sha256=yjTnk0xWvDnZeCaB11TcRGxVLTXWPRnGBsekiMcyRvU,21317
 crackerjack/adapters/__init__.py,sha256=k-8ajMDL9DS9hV2FYOu694nmNQg3HkudJRuNcXmx8N4,451
 crackerjack/adapters/lsp_client.py,sha256=4kQ3T5JiWC7uc6kOjZuPdtUboseKSDjZpuKQpV74onc,10963
 crackerjack/adapters/rust_tool_adapter.py,sha256=ui_qMt_WIwInRvRCeT7MnIdp8eln7Fvp4hakXQiVnjg,5999
@@ -54,7 +54,7 @@ crackerjack/core/service_watchdog.py,sha256=Ttj1imOxvUea4Tkf5JO1e2dQtGIK7D-bX1xO
 crackerjack/core/session_coordinator.py,sha256=TgoGE9DfXe2x-OkH93Ld9dX9ROjx2_mZFkGXen-z5YI,15680
 crackerjack/core/timeout_manager.py,sha256=_sbEsfYDwWx7y0Pn89QCoAZ5DpWIbCdtR9qkG_Kqj5E,15013
 crackerjack/core/websocket_lifecycle.py,sha256=74kn6ugu6FLlDQhCNSPgqguCFwRoT1WFOvtl8G2OyFc,12860
-crackerjack/core/workflow_orchestrator.py,sha256=jh8G1xKqxXwD0yGaFHgdESRjm23-kUZt4qriMJltowM,70789
+crackerjack/core/workflow_orchestrator.py,sha256=y_bYIZ2cn-DD8J1A9xkS9TawUJ8qdeirmB5HHrzTwg8,71867
 crackerjack/docs/INDEX.md,sha256=a6CGFEeL5DX_FRft_JFWd0nOxoBmCSSp-QHIC3B7ato,342
 crackerjack/docs/generated/api/API_REFERENCE.md,sha256=mWoqImZA7AhDvRqqF1MhUo70g_pnZr3NoBeZQRotqN8,155816
 crackerjack/docs/generated/api/CLI_REFERENCE.md,sha256=ikuG0hO5EjIiQlJtAUnvEuAhXDa-JHPULPXNNmUwvk4,2805
@@ -65,7 +65,7 @@ crackerjack/documentation/__init__.py,sha256=gGR--er5oTHhbwLKOHVlU2QgGmQtA0qUXf3
 crackerjack/documentation/ai_templates.py,sha256=GRBKB5bqWudh9MDLjo1b3vNiFAgpL62ezzRp_WxTews,21629
 crackerjack/documentation/dual_output_generator.py,sha256=w7rDthOnyFeRPQDWvYiR4aiScPxsHzkwjJ3blMwT9-w,28552
 crackerjack/documentation/mkdocs_integration.py,sha256=KqU2_9mA-rjP_VDrrfr6KTuPWtTlcvkInPxoH03LTC0,15657
-crackerjack/documentation/reference_generator.py,sha256=qthAvJU32xUjpl6GZ5s0sWILdCS3OGQLzIuw6UBsUU4,30618
+crackerjack/documentation/reference_generator.py,sha256=RezcoengHOnPJp988KB--EYcMfjJqPpWWFIvzvOMNCc,33094
 crackerjack/executors/__init__.py,sha256=HF-DmXvKN45uKKDdiMxOT9bYxuy1B-Z91BihOhkK5lg,322
 crackerjack/executors/async_hook_executor.py,sha256=FmKpiAxpZXKwvOWXnRQ73N-reDfX8NusESQ9a4HeacM,17620
 crackerjack/executors/cached_hook_executor.py,sha256=izwdW0B22EZcl_2_llmTIyq5oTcZDZTRL2G97ZwYiXg,11173
@@ -74,7 +74,7 @@ crackerjack/executors/hook_lock_manager.py,sha256=ft24q6VFEkW_QrifNnSlrQeHGx9GuJ
 crackerjack/executors/individual_hook_executor.py,sha256=t0W9vuqLGPx0HmbTo01N9MRFyqLfY0ZLG06ZIA5qfBY,24362
 crackerjack/executors/lsp_aware_hook_executor.py,sha256=aZxtTwpaDxfmN71II2MEAtfzEst-jPJp-GXmMLwnibA,10388
 crackerjack/executors/tool_proxy.py,sha256=dJnrt72aFXEMuZLsgrLZrf51vfELDaXs5nBxzGHu7SQ,14881
-crackerjack/hooks/lsp_hook.py,sha256=hJCkJ-jUJasE35XPWdnGRDXgynEh2-gUiEd1wxLFp48,2397
+crackerjack/hooks/lsp_hook.py,sha256=MPP9EYmKdZMNBvAQSAwzI5L8TkwKTd0uVx3heaTHmM0,2877
 crackerjack/intelligence/__init__.py,sha256=3Sty6xFyxBEXTyy8W34dpAQk7S7m8SnxUz4wrb3xrZc,878
 crackerjack/intelligence/adaptive_learning.py,sha256=Q0pUyxzBBCtySTfp96zHObQVAUaN0c5kEFOFJKIG0j8,25610
 crackerjack/intelligence/agent_orchestrator.py,sha256=YOG2sQc0l5ddz7TzRZ_1YAugTNwuyY1brWrlj5tnMhk,16728
@@ -84,7 +84,7 @@ crackerjack/intelligence/integration.py,sha256=vVaC2Fp5RbbABpaohCePzGw1XANuRztGl
 crackerjack/managers/__init__.py,sha256=PFWccXx4hDQA76T02idAViOLVD-aPeVpgjdfSkh_Dmk,298
 crackerjack/managers/async_hook_manager.py,sha256=c0HFR98sFwfk0uZ3NmAe_6OVZpBrq9I570V8A2DoIxw,5129
 crackerjack/managers/hook_manager.py,sha256=_FT0ngwPwujqg0KZGpLz-pP07mwDmptJ5pVkiy5yS8k,7820
-crackerjack/managers/publish_manager.py,sha256=5jpYM2IeTxavP2KYypZqz83ASQrBQDOhcKpws8DLFbM,22040
+crackerjack/managers/publish_manager.py,sha256=Pe0zWtLaho5BCTO8-EC9sY0Gl4L1B2guDM2D8B8TryA,22034
 crackerjack/managers/test_command_builder.py,sha256=1TlPzddNcDDxRORH6UvAudcbRc6hKwFyknSEVLkiWAo,3459
 crackerjack/managers/test_executor.py,sha256=2837Ti4OaNsmLxnmELjbQ18hmfL0-Z2EW-W2UeFSDcE,13871
 crackerjack/managers/test_manager.py,sha256=BRPBWXx4flPDK0w96xyHhg-9dmUca1vpKQRM2VofSlI,13158
@@ -110,7 +110,7 @@ crackerjack/mcp/tools/__init__.py,sha256=T_RMPXHQQWJLvSJjrPkJYtWi5tmyoRrzm0WS2G-
 crackerjack/mcp/tools/core_tools.py,sha256=8gytjhqxKglR-ZvLIy0DwJzzaqStex_s9WHiAjkXlD0,14612
 crackerjack/mcp/tools/error_analyzer.py,sha256=8ap3_TIqEfrN0n49w_wJFRE3zu7eHB9E8UyXqqz7unM,8515
 crackerjack/mcp/tools/execution_tools.py,sha256=iMtcTm45v04wNgfiIdzOjMXyB-lZ9x-yUtN9SuLGxNI,10410
-crackerjack/mcp/tools/execution_tools_backup.py,sha256=aq3njWeBlHT8EbBlmWsdtKwYujssV1hyI5waGku68Ec,33269
+crackerjack/mcp/tools/execution_tools_backup.py,sha256=sWOtid00SkuonFLT2XCtljOGZiibbaIXzEdLWsPrXyI,33351
 crackerjack/mcp/tools/intelligence_tool_registry.py,sha256=eAOBzW3EZTKSz_MeYVzgjD6a1xVZFSXUdgOsgcQLSBk,1262
 crackerjack/mcp/tools/intelligence_tools.py,sha256=R0TK-sLuCezJQu0FfTg1xXs-xI_oI2aJeueZgOrM58g,9106
 crackerjack/mcp/tools/monitoring_tools.py,sha256=5RYbytBmLjJdz1sE33xYchdrO9LgzGwSvsqRsZIV7oA,21804
@@ -157,9 +157,9 @@ crackerjack/services/backup_service.py,sha256=0e8AAo9svSBtbsbI9vwnAVSilB2fjph61l
 crackerjack/services/bounded_status_operations.py,sha256=mrBkUQwgtYjkbp-Y-5MdrU2A3rp3ZLVgOJv9vLdnJ8k,18763
 crackerjack/services/cache.py,sha256=FutQKxItKSdQFzOlWQaQzVBEfn6lbPXCDdvNnz3NCDQ,14536
 crackerjack/services/changelog_automation.py,sha256=KUeXCYLihRfLR0mUIRiI2aRQdCfe-45GnbB2gYNJJQE,14095
-crackerjack/services/config.py,sha256=fF3EpPfIxFBmZ9oTr7V64zCMBmxHWCmD_649qr0dgsI,13590
+crackerjack/services/config.py,sha256=1gUQkcHPCGHVYSlx6mcrJlJLVIWhdaL7RjEmuy8_ev4,13704
 crackerjack/services/config_integrity.py,sha256=Ac6-c7WuupsyrP2dxx_ijgjzpNnx9G0NWsXB-SZjelg,2904
-crackerjack/services/config_merge.py,sha256=FPh4u4J68JkNVf0AT1paNeEy2MjusSbYu9kN72LzR9w,18825
+crackerjack/services/config_merge.py,sha256=ubApDKbYMREaHARP3oaW9vY8iVeYuknsr6tJIiIz-_E,18999
 crackerjack/services/config_template.py,sha256=RgSYFVNBxdBfMitlRqz7bzkEHaQhEWMm3pUMS7maRFU,18035
 crackerjack/services/contextual_ai_assistant.py,sha256=6Pnb2r824c4JYkP5mtCH8sJ2OPPvI-KtzbXcosspCfE,19962
 crackerjack/services/coverage_badge_service.py,sha256=gzC3LEyVLt4rpf378APsFVRGgNwkLc50w9S_9xEPPoM,6645
@@ -199,7 +199,7 @@ crackerjack/services/regex_patterns.py,sha256=iis9gSzXZtnX14lODGfSUsf7bcCRTw7rdS
 crackerjack/services/regex_utils.py,sha256=e7AD59_L-T5-oOxzqsGgrLd94uxRE9aKnwasZkohwI8,14966
 crackerjack/services/secure_path_utils.py,sha256=aHsLwxDch42DidPYtTL_ko40g2rhbXDLnRhcx2LlGk8,16688
 crackerjack/services/secure_status_formatter.py,sha256=yhwNtzvvQVcuHsNOTNZMzlqIMQT9zx-lzAtq9LuSDuk,14121
-crackerjack/services/secure_subprocess.py,sha256=upuiBL0sYIElC8DWQ622-A6572zBaSBoMPVnNM8AeaQ,19838
+crackerjack/services/secure_subprocess.py,sha256=tDHyuxavTES1uXzJOdxZlza8d92hvza2xzx5JMamsoA,20488
 crackerjack/services/security.py,sha256=plgIz-B8oYN_mpF4NYrqHnT7TRcsp4jr0-YlV9WgD5o,7298
 crackerjack/services/security_logger.py,sha256=AAjd9VKVmCo158UifyEKd79VgtWKeuaIVyXYL8qvqT8,17001
 crackerjack/services/server_manager.py,sha256=MwvMMxhaCiZD4pcKM2ODXB-gu2s22n_v_uIqrwoJsHs,11934
@@ -221,11 +221,11 @@ crackerjack/slash_commands/run.md,sha256=VEWWset52jPV0m00LnQpjRkHL8g8XRPYAzgOq6B
 crackerjack/slash_commands/status.md,sha256=U3qqppVLtIIm2lEiMYaKagaHYLI9UplL7OH1j6SRJGw,3921
 crackerjack/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 crackerjack/tools/validate_input_validator_patterns.py,sha256=NN7smYlXWrHLQXTb-81gRam2vjW-cJav92f1klPA0qA,8234
-crackerjack/tools/validate_regex_patterns.py,sha256=9ejFb7Tw1js_oydzuEeeeXvrU5ipHUEX9ATBfkLCCE8,5811
+crackerjack/tools/validate_regex_patterns.py,sha256=J7GG9EP1fASpRIsG8qRPeiCSkdCwmk0sdo29GgoJ6w8,5863
 crackerjack/ui/__init__.py,sha256=eMb1OeTU-dSLICAACn0YdYB4Amdr8wHckjKfn0wOIZE,37
 crackerjack/ui/server_panels.py,sha256=F5IH6SNN06BaZQMsFx_D-OA286aojmaFPJ5kvvSRv_c,4232
-crackerjack-0.37.7.dist-info/METADATA,sha256=BmdPeVCTs9I1CJz43F4edjP6sV3PQxKk8ffgBE2IYwQ,37949
-crackerjack-0.37.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-crackerjack-0.37.7.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
-crackerjack-0.37.7.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
-crackerjack-0.37.7.dist-info/RECORD,,
+crackerjack-0.37.9.dist-info/METADATA,sha256=CCZxJnuN5szGZEggJFKNED1WCXd8B1EY7xHAaqL7E6M,37949
+crackerjack-0.37.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+crackerjack-0.37.9.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
+crackerjack-0.37.9.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
+crackerjack-0.37.9.dist-info/RECORD,,