crackerjack 0.37.8__tar.gz → 0.37.9__tar.gz

crackerjack-0.37.9/.codespell-ignore

@@ -0,0 +1,2 @@
+# Project-specific codespell ignore words
+# Add words here that should be ignored by codespell

crackerjack-0.37.9/.codespellrc

@@ -0,0 +1,5 @@
+[codespell]
+skip = */data/*,htmlcov/*
+quiet-level = 3
+ignore-words-list = crate,uptodate,nd,nin
+ignore-words = .codespell-ignore

{crackerjack-0.37.8 → crackerjack-0.37.9}/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.37.9] - 2025-09-16
+
+### Documentation
+
+- core: Update 5 files
+
 ## [0.37.8] - 2025-09-16
 
 ### Documentation

{crackerjack-0.37.8 → crackerjack-0.37.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.37.8
+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.8 → crackerjack-0.37.9}/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-0.37.8 → crackerjack-0.37.9}/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-0.37.8 → crackerjack-0.37.9}/crackerjack/dynamic_config.py

@@ -1,5 +1,6 @@
 import tempfile
 import typing as t
+from contextlib import suppress
 from pathlib import Path
 
 import jinja2
@@ -469,29 +470,26 @@ class DynamicConfigGenerator:
 
     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:
@@ -502,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-0.37.8 → crackerjack-0.37.9}/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-0.37.8 → crackerjack-0.37.9}/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-0.37.8 → crackerjack-0.37.9}/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