crackerjack 0.31.8__py3-none-any.whl → 0.31.10__py3-none-any.whl

crackerjack/core/async_workflow_orchestrator.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 from rich.console import Console
 
+from crackerjack.agents.base import FixResult, Issue, IssueType, Priority
 from crackerjack.models.protocols import OptionsProtocol
 
 from .phase_coordinator import PhaseCoordinator
@@ -233,6 +234,113 @@ class AsyncWorkflowPipeline:
 
         return "continue"
 
+    def _parse_issues_for_agents(
+        self, test_issues: list[str], hook_issues: list[str]
+    ) -> list[Issue]:
+        """Parse string issues into structured Issue objects for AI agent processing."""
+        structured_issues = []
+
+        # Parse hook issues using dedicated parsers
+        for issue in hook_issues:
+            parsed_issue = self._parse_single_hook_issue(issue)
+            structured_issues.append(parsed_issue)
+
+        # Parse test issues using dedicated parser
+        for issue in test_issues:
+            parsed_issue = self._parse_single_test_issue(issue)
+            structured_issues.append(parsed_issue)
+
+        return structured_issues
+
+    def _parse_single_hook_issue(self, issue: str) -> Issue:
+        """Parse a single hook issue into structured format."""
+        from crackerjack.agents.base import IssueType, Priority
+
+        # Try refurb-specific parsing first
+        if "refurb:" in issue and "[FURB" in issue:
+            return self._parse_refurb_issue(issue)
+
+        # Use generic hook issue parsers
+        hook_type_mapping = {
+            "pyright:": (IssueType.TYPE_ERROR, Priority.HIGH, "pyright"),
+            "Type error": (IssueType.TYPE_ERROR, Priority.HIGH, "pyright"),
+            "bandit:": (IssueType.SECURITY, Priority.HIGH, "bandit"),
+            "vulture:": (IssueType.DEAD_CODE, Priority.MEDIUM, "vulture"),
+            "complexipy:": (IssueType.COMPLEXITY, Priority.MEDIUM, "complexipy"),
+        }
+
+        for keyword, (issue_type, priority, stage) in hook_type_mapping.items():
+            if keyword in issue:
+                return self._create_generic_issue(issue, issue_type, priority, stage)
+
+        # Default to generic hook issue
+        return self._create_generic_issue(
+            issue, IssueType.FORMATTING, Priority.MEDIUM, "hook"
+        )
+
+    def _parse_refurb_issue(self, issue: str) -> Issue:
+        """Parse refurb-specific issue format."""
+        import re
+        import uuid
+
+        from crackerjack.agents.base import Issue, IssueType, Priority
+
+        match = re.search(r"refurb:\s*(.+?):(\d+):(\d+)\s+\[(\w+)\]:\s*(.+)", issue)
+        if match:
+            file_path, line_num, _, error_code, message = match.groups()
+            return Issue(
+                id=str(uuid.uuid4()),
+                type=IssueType.FORMATTING,
+                severity=Priority.MEDIUM,
+                message=f"[{error_code}] {message}",
+                file_path=file_path,
+                line_number=int(line_num),
+                details=[issue],
+                stage="refurb",
+            )
+
+        # Fallback to generic parsing if regex fails
+        return self._create_generic_issue(
+            issue, IssueType.FORMATTING, Priority.MEDIUM, "refurb"
+        )
+
+    def _parse_single_test_issue(self, issue: str) -> Issue:
+        """Parse a single test issue into structured format."""
+        import uuid
+
+        from crackerjack.agents.base import Issue, IssueType, Priority
+
+        if "FAILED" in issue or "ERROR" in issue:
+            severity = Priority.HIGH
+        else:
+            severity = Priority.MEDIUM
+
+        return Issue(
+            id=str(uuid.uuid4()),
+            type=IssueType.TEST_FAILURE,
+            severity=severity,
+            message=issue,
+            details=[issue],
+            stage="test",
+        )
+
+    def _create_generic_issue(
+        self, issue: str, issue_type: IssueType, priority: Priority, stage: str
+    ) -> Issue:
+        """Create a generic Issue object with standard fields."""
+        import uuid
+
+        from crackerjack.agents.base import Issue
+
+        return Issue(
+            id=str(uuid.uuid4()),
+            type=issue_type,
+            severity=priority,
+            message=issue,
+            details=[issue],
+            stage=stage,
+        )
+
     async def _run_final_workflow_phases(self, options: OptionsProtocol) -> bool:
         """Run the final publishing and commit phases."""
         if not self.phases.run_publishing_phase(options):
@@ -263,7 +371,13 @@ class AsyncWorkflowPipeline:
             if success:
                 return []
             else:
-                return ["Test failures detected - see logs for details"]
+                # Get specific test failure details from test manager
+                test_failures = self.phases.test_manager.get_test_failures()
+                if test_failures:
+                    return [f"Test failure: {failure}" for failure in test_failures]
+                else:
+                    # Fallback if no specific failures captured
+                    return ["Test failures detected - see logs for details"]
         except Exception as e:
             return [f"Test execution error: {e}"]
 
@@ -272,11 +386,25 @@ class AsyncWorkflowPipeline:
     ) -> list[str]:
         """Collect all comprehensive hook issues without stopping on first failure."""
         try:
-            success = await self._run_comprehensive_hooks_async(options)
-            if success:
-                return []
-            else:
-                return ["Comprehensive hook failures detected - see logs for details"]
+            # Run hooks and capture detailed results
+            hook_results = await asyncio.to_thread(
+                self.phases.hook_manager.run_comprehensive_hooks,
+            )
+
+            # Extract specific issues from failed hooks
+            all_issues = []
+            for result in hook_results:
+                if (
+                    result.status in ("failed", "error", "timeout")
+                    and result.issues_found
+                ):
+                    # Add hook context to each issue for better AI agent understanding
+                    hook_context = f"{result.name}: "
+                    for issue in result.issues_found:
+                        all_issues.append(hook_context + issue)
+
+            return all_issues
+
         except Exception as e:
             return [f"Comprehensive hooks error: {e}"]
 
@@ -287,7 +415,7 @@ class AsyncWorkflowPipeline:
         hook_issues: list[str],
         iteration: int,
     ) -> bool:
-        """Apply AI fixes for all collected issues in batch."""
+        """Apply AI fixes for all collected issues in batch using AgentCoordinator."""
         all_issues = test_issues + hook_issues
         if not all_issues:
             return True
@@ -296,24 +424,62 @@ class AsyncWorkflowPipeline:
             f"🔧 Applying AI fixes for {len(all_issues)} issues in iteration {iteration}"
         )
 
-        # This would integrate with the AI agent system to actually apply fixes
-        # For now, we'll simulate the fixing process
         try:
-            # In a real implementation, this would:
-            # 1. Analyze all collected issues
-            # 2. Generate fixes using AI agents
-            # 3. Apply the fixes to source code
-            # 4. Return success/failure status
+            return await self._execute_ai_fix_workflow(
+                test_issues, hook_issues, iteration
+            )
+        except Exception as e:
+            return self._handle_ai_fix_error(e)
 
-            # Placeholder for actual AI fixing logic
-            await asyncio.sleep(0.1)  # Simulate processing time
+    async def _execute_ai_fix_workflow(
+        self, test_issues: list[str], hook_issues: list[str], iteration: int
+    ) -> bool:
+        """Execute the AI fix workflow and return success status."""
+        structured_issues = self._parse_issues_for_agents(test_issues, hook_issues)
 
-            self.console.print(f"✅ AI fixes applied for iteration {iteration}")
+        if not structured_issues:
+            self.console.print("⚠️ No actionable issues found for AI agents")
             return True
 
-        except Exception as e:
-            self.logger.error(f"AI fixing failed: {e}")
-            return False
+        coordinator = self._create_agent_coordinator()
+        fix_result = await coordinator.handle_issues(structured_issues)
+
+        self._report_fix_results(fix_result, iteration)
+        return fix_result.success
+
+    def _create_agent_coordinator(self):
+        """Create and configure the AI agent coordinator."""
+        from crackerjack.agents.base import AgentContext
+        from crackerjack.agents.coordinator import AgentCoordinator
+
+        context = AgentContext(project_path=self.pkg_path)
+        return AgentCoordinator(context)
+
+    def _report_fix_results(self, fix_result: FixResult, iteration: int) -> None:
+        """Report the results of AI fix attempts to the console."""
+        if fix_result.success:
+            self._report_successful_fixes(fix_result, iteration)
+        else:
+            self._report_failed_fixes(fix_result, iteration)
+
+    def _report_successful_fixes(self, fix_result: FixResult, iteration: int) -> None:
+        """Report successful AI fixes to the console."""
+        self.console.print(f"✅ AI fixes applied successfully in iteration {iteration}")
+        if fix_result.fixes_applied:
+            self.console.print(f"   Applied {len(fix_result.fixes_applied)} fixes")
+
+    def _report_failed_fixes(self, fix_result: FixResult, iteration: int) -> None:
+        """Report failed AI fixes to the console."""
+        self.console.print(f"⚠️ Some AI fixes failed in iteration {iteration}")
+        if fix_result.remaining_issues:
+            for error in fix_result.remaining_issues[:3]:  # Show first 3 errors
+                self.console.print(f"   Error: {error}")
+
+    def _handle_ai_fix_error(self, error: Exception) -> bool:
+        """Handle errors during AI fix execution."""
+        self.logger.error(f"AI fixing failed: {error}")
+        self.console.print(f"❌ AI agent system error: {error}")
+        return False
 
 
 class AsyncWorkflowOrchestrator:

crackerjack/core/phase_coordinator.py

@@ -157,7 +157,7 @@ class PhaseCoordinator:
                 "CLAUDE.md",
                 "RULES.md",
                 ".gitignore",
-                "mcp.json",
+                "example.mcp.json",
                 "uv.lock",
             ]
 

crackerjack/core/workflow_orchestrator.py

@@ -62,81 +62,122 @@ class WorkflowPipeline:
             skip_hooks=getattr(options, "skip_hooks", False),
         ):
             start_time = time.time()
-            self.session.initialize_session_tracking(options)
-            self.session.track_task("workflow", "Complete crackerjack workflow")
-
-            if self._should_debug():
-                self.debugger.log_workflow_phase(
-                    "workflow_execution",
-                    "started",
-                    details={
-                        "testing": getattr(options, "testing", False),
-                        "skip_hooks": getattr(options, "skip_hooks", False),
-                        "ai_agent": getattr(options, "ai_agent", False),
-                    },
-                )
-
-            if hasattr(options, "cleanup"):
-                self.session.set_cleanup_config(options.cleanup)
-
-            self.logger.info(
-                "Starting complete workflow execution",
-                testing=getattr(options, "testing", False),
-                skip_hooks=getattr(options, "skip_hooks", False),
-                package_path=str(self.pkg_path),
-            )
+            self._initialize_workflow_session(options)
 
             try:
-                success = await self._execute_workflow_phases(options)
-                self.session.finalize_session(start_time, success)
-
-                duration = time.time() - start_time
-                self.logger.info(
-                    "Workflow execution completed",
-                    success=success,
-                    duration_seconds=round(duration, 2),
-                )
-
-                if self._should_debug():
-                    # Set final workflow success status
-                    self.debugger.set_workflow_success(success)
-
-                    self.debugger.log_workflow_phase(
-                        "workflow_execution",
-                        "completed" if success else "failed",
-                        duration=duration,
-                    )
-                    if self.debugger.enabled:
-                        self.debugger.print_debug_summary()
-
+                success = await self._execute_workflow_with_timing(options, start_time)
                 return success
 
             except KeyboardInterrupt:
-                self.console.print("Interrupted by user")
-                self.session.fail_task("workflow", "Interrupted by user")
-                self.logger.warning("Workflow interrupted by user")
-                return False
+                return self._handle_user_interruption()
 
             except Exception as e:
-                self.console.print(f"Error: {e}")
-                self.session.fail_task("workflow", f"Unexpected error: {e}")
-                self.logger.exception(
-                    "Workflow execution failed",
-                    error=str(e),
-                    error_type=type(e).__name__,
-                )
-                return False
+                return self._handle_workflow_exception(e)
 
             finally:
                 self.session.cleanup_resources()
 
+    def _initialize_workflow_session(self, options: OptionsProtocol) -> None:
+        """Initialize session tracking and debug logging for workflow execution."""
+        self.session.initialize_session_tracking(options)
+        self.session.track_task("workflow", "Complete crackerjack workflow")
+
+        self._log_workflow_startup_debug(options)
+        self._configure_session_cleanup(options)
+        self._log_workflow_startup_info(options)
+
+    def _log_workflow_startup_debug(self, options: OptionsProtocol) -> None:
+        """Log debug information for workflow startup."""
+        if not self._should_debug():
+            return
+
+        self.debugger.log_workflow_phase(
+            "workflow_execution",
+            "started",
+            details={
+                "testing": getattr(options, "testing", False),
+                "skip_hooks": getattr(options, "skip_hooks", False),
+                "ai_agent": getattr(options, "ai_agent", False),
+            },
+        )
+
+    def _configure_session_cleanup(self, options: OptionsProtocol) -> None:
+        """Configure session cleanup settings if specified."""
+        if hasattr(options, "cleanup"):
+            self.session.set_cleanup_config(options.cleanup)
+
+    def _log_workflow_startup_info(self, options: OptionsProtocol) -> None:
+        """Log informational message about workflow startup."""
+        self.logger.info(
+            "Starting complete workflow execution",
+            testing=getattr(options, "testing", False),
+            skip_hooks=getattr(options, "skip_hooks", False),
+            package_path=str(self.pkg_path),
+        )
+
+    async def _execute_workflow_with_timing(
+        self, options: OptionsProtocol, start_time: float
+    ) -> bool:
+        """Execute workflow phases and handle success/completion logging."""
+        success = await self._execute_workflow_phases(options)
+        self.session.finalize_session(start_time, success)
+
+        duration = time.time() - start_time
+        self._log_workflow_completion(success, duration)
+        self._log_workflow_completion_debug(success, duration)
+
+        return success
+
+    def _log_workflow_completion(self, success: bool, duration: float) -> None:
+        """Log workflow completion information."""
+        self.logger.info(
+            "Workflow execution completed",
+            success=success,
+            duration_seconds=round(duration, 2),
+        )
+
+    def _log_workflow_completion_debug(self, success: bool, duration: float) -> None:
+        """Log debug information for workflow completion."""
+        if not self._should_debug():
+            return
+
+        self.debugger.set_workflow_success(success)
+        self.debugger.log_workflow_phase(
+            "workflow_execution",
+            "completed" if success else "failed",
+            duration=duration,
+        )
+
+        if self.debugger.enabled:
+            self.debugger.print_debug_summary()
+
+    def _handle_user_interruption(self) -> bool:
+        """Handle KeyboardInterrupt gracefully."""
+        self.console.print("Interrupted by user")
+        self.session.fail_task("workflow", "Interrupted by user")
+        self.logger.warning("Workflow interrupted by user")
+        return False
+
+    def _handle_workflow_exception(self, error: Exception) -> bool:
+        """Handle unexpected workflow exceptions."""
+        self.console.print(f"Error: {error}")
+        self.session.fail_task("workflow", f"Unexpected error: {error}")
+        self.logger.exception(
+            "Workflow execution failed",
+            error=str(error),
+            error_type=type(error).__name__,
+        )
+        return False
+
     async def _execute_workflow_phases(self, options: OptionsProtocol) -> bool:
         success = True
         self.phases.run_configuration_phase(options)
+
         if not self.phases.run_cleaning_phase(options):
             success = False
             self.session.fail_task("workflow", "Cleaning phase failed")
             return False
+
         if not await self._execute_quality_phase(options):
             success = False
             return False
@@ -224,6 +265,21 @@ class WorkflowPipeline:
     ) -> bool:
         """Handle standard workflow where all phases must pass."""
         success = testing_passed and comprehensive_passed
+
+        # Debug information for workflow continuation issues
+        if not success and getattr(options, "verbose", False):
+            self.console.print(
+                f"[yellow]⚠️  Workflow stopped - testing_passed: {testing_passed}, comprehensive_passed: {comprehensive_passed}[/yellow]"
+            )
+            if not testing_passed:
+                self.console.print(
+                    "[yellow]   → Tests reported failure despite appearing successful[/yellow]"
+                )
+            if not comprehensive_passed:
+                self.console.print(
+                    "[yellow]   → Comprehensive hooks reported failure despite appearing successful[/yellow]"
+                )
+
         if options.ai_agent and self._should_debug():
             self.debugger.log_iteration_end(iteration, success)
         return success
@@ -560,6 +616,80 @@ class WorkflowPipeline:
         issues: list[Issue] = []
         hook_count = 0
 
+        try:
+            hook_results = self.phases.hook_manager.run_comprehensive_hooks()
+            issues, hook_count = self._process_hook_results(hook_results)
+        except Exception:
+            issues, hook_count = self._fallback_to_session_tracker()
+
+        return issues, hook_count
+
+    def _process_hook_results(self, hook_results: t.Any) -> tuple[list[Issue], int]:
+        """Process hook results and extract issues."""
+        issues: list[Issue] = []
+        hook_count = 0
+
+        for result in hook_results:
+            if not self._is_hook_result_failed(result):
+                continue
+
+            hook_count += 1
+            result_issues = self._extract_issues_from_hook_result(result)
+            issues.extend(result_issues)
+
+        return issues, hook_count
+
+    def _is_hook_result_failed(self, result: t.Any) -> bool:
+        """Check if hook result indicates failure."""
+        return result.status in ("failed", "error", "timeout")
+
+    def _extract_issues_from_hook_result(self, result: t.Any) -> list[Issue]:
+        """Extract issues from a single hook result."""
+        if result.issues_found:
+            return self._create_specific_issues_from_hook_result(result)
+        return [self._create_generic_issue_from_hook_result(result)]
+
+    def _create_specific_issues_from_hook_result(self, result: t.Any) -> list[Issue]:
+        """Create specific issues from hook result with detailed information."""
+        issues: list[Issue] = []
+        hook_context = f"{result.name}: "
+
+        for issue_text in result.issues_found:
+            parsed_issues = self._parse_issues_for_agents([hook_context + issue_text])
+            issues.extend(parsed_issues)
+
+        return issues
+
+    def _create_generic_issue_from_hook_result(self, result: t.Any) -> Issue:
+        """Create a generic issue for hook failure without specific details."""
+        issue_type = self._determine_hook_issue_type(result.name)
+        return Issue(
+            id=f"hook_failure_{result.name}",
+            type=issue_type,
+            severity=Priority.MEDIUM,
+            message=f"Hook {result.name} failed with no specific details",
+            stage="comprehensive",
+        )
+
+    def _determine_hook_issue_type(self, hook_name: str) -> IssueType:
+        """Determine issue type based on hook name."""
+        formatting_hooks = {
+            "trailing-whitespace",
+            "end-of-file-fixer",
+            "ruff-format",
+            "ruff-check",
+        }
+        return (
+            IssueType.FORMATTING
+            if hook_name in formatting_hooks
+            else IssueType.TYPE_ERROR
+        )
+
+    def _fallback_to_session_tracker(self) -> tuple[list[Issue], int]:
+        """Fallback to session tracker if hook manager fails."""
+        issues: list[Issue] = []
+        hook_count = 0
+
         if not self.session.session_tracker:
             return issues, hook_count
 
@@ -679,6 +809,61 @@ class WorkflowPipeline:
 
         return issues
 
+    def _parse_issues_for_agents(self, issue_strings: list[str]) -> list[Issue]:
+        """Parse string issues into structured Issue objects for AI agents."""
+        issues: list[Issue] = []
+
+        for i, issue_str in enumerate(issue_strings):
+            # Determine issue type from content patterns
+            issue_type = IssueType.FORMATTING
+            priority = Priority.MEDIUM
+
+            if any(
+                keyword in issue_str.lower()
+                for keyword in ("type", "annotation", "pyright")
+            ):
+                issue_type = IssueType.TYPE_ERROR
+                priority = Priority.HIGH
+            elif any(
+                keyword in issue_str.lower()
+                for keyword in ("security", "bandit", "hardcoded")
+            ):
+                issue_type = IssueType.SECURITY
+                priority = Priority.HIGH
+            elif any(
+                keyword in issue_str.lower() for keyword in ("complexity", "complexipy")
+            ):
+                issue_type = IssueType.COMPLEXITY
+                priority = Priority.HIGH
+            elif any(
+                keyword in issue_str.lower()
+                for keyword in ("unused", "dead", "vulture")
+            ):
+                issue_type = IssueType.DEAD_CODE
+                priority = Priority.MEDIUM
+            elif any(
+                keyword in issue_str.lower()
+                for keyword in ("performance", "refurb", "furb")
+            ):
+                issue_type = IssueType.PERFORMANCE
+                priority = Priority.MEDIUM
+            elif any(
+                keyword in issue_str.lower() for keyword in ("import", "creosote")
+            ):
+                issue_type = IssueType.IMPORT_ERROR
+                priority = Priority.MEDIUM
+
+            issue = Issue(
+                id=f"parsed_issue_{i}",
+                type=issue_type,
+                severity=priority,
+                message=issue_str.strip(),
+                stage="comprehensive",
+            )
+            issues.append(issue)
+
+        return issues
+
     def _log_failure_counts_if_debugging(
         self, test_count: int, hook_count: int
     ) -> None:

crackerjack/executors/hook_executor.py

@@ -154,58 +154,106 @@ class HookExecutor:
         start_time = time.time()
 
         try:
-            clean_env = self._get_clean_environment()
-            result = subprocess.run(
-                hook.get_command(),
-                check=False,
-                cwd=self.pkg_path,
-                text=True,
-                timeout=hook.timeout,
-                env=clean_env,
-                capture_output=True,
-            )
-
+            result = self._run_hook_subprocess(hook)
             duration = time.time() - start_time
 
-            # Only display raw output in verbose mode, and only for failed hooks
-            if result.returncode != 0 and self.verbose:
-                if result.stdout:
-                    self.console.print(result.stdout)
-                if result.stderr:
-                    self.console.print(result.stderr)
-
-            return HookResult(
-                id=hook.name,
-                name=hook.name,
-                status="passed" if result.returncode == 0 else "failed",
-                duration=duration,
-                files_processed=0,
-                issues_found=[]
-                if result.returncode == 0
-                else [f"Hook failed with code {result.returncode}"],
-                stage=hook.stage.value,
-            )
+            self._display_hook_output_if_needed(result)
+            return self._create_hook_result_from_process(hook, result, duration)
 
         except subprocess.TimeoutExpired:
-            duration = time.time() - start_time
-            return HookResult(
-                id=hook.name,
-                name=hook.name,
-                status="timeout",
-                duration=duration,
-                issues_found=[f"Hook timed out after {duration:.1f}s"],
-                stage=hook.stage.value,
-            )
+            return self._create_timeout_result(hook, start_time)
+
         except Exception as e:
-            duration = time.time() - start_time
-            return HookResult(
-                id=hook.name,
-                name=hook.name,
-                status="error",
-                duration=duration,
-                issues_found=[str(e)],
-                stage=hook.stage.value,
-            )
+            return self._create_error_result(hook, start_time, e)
+
+    def _run_hook_subprocess(
+        self, hook: HookDefinition
+    ) -> subprocess.CompletedProcess[str]:
+        """Execute hook subprocess with clean environment."""
+        clean_env = self._get_clean_environment()
+        return subprocess.run(
+            hook.get_command(),
+            check=False,
+            cwd=self.pkg_path,
+            text=True,
+            timeout=hook.timeout,
+            env=clean_env,
+            capture_output=True,
+        )
+
+    def _display_hook_output_if_needed(
+        self, result: subprocess.CompletedProcess[str]
+    ) -> None:
+        """Display hook output in verbose mode for failed hooks."""
+        if result.returncode == 0 or not self.verbose:
+            return
+
+        if result.stdout:
+            self.console.print(result.stdout)
+        if result.stderr:
+            self.console.print(result.stderr)
+
+    def _create_hook_result_from_process(
+        self,
+        hook: HookDefinition,
+        result: subprocess.CompletedProcess[str],
+        duration: float,
+    ) -> HookResult:
+        """Create HookResult from successful subprocess execution."""
+        status = "passed" if result.returncode == 0 else "failed"
+        issues_found = self._extract_issues_from_process_output(result)
+
+        return HookResult(
+            id=hook.name,
+            name=hook.name,
+            status=status,
+            duration=duration,
+            files_processed=0,
+            issues_found=issues_found,
+            stage=hook.stage.value,
+        )
+
+    def _extract_issues_from_process_output(
+        self, result: subprocess.CompletedProcess[str]
+    ) -> list[str]:
+        """Extract specific issues from subprocess output for failed hooks."""
+        if result.returncode == 0:
+            return []
+
+        error_output = (result.stdout + result.stderr).strip()
+        if error_output:
+            return [line.strip() for line in error_output.split("\n") if line.strip()]
+
+        # Fallback to generic message if no output captured
+        return [f"Hook failed with code {result.returncode}"]
+
+    def _create_timeout_result(
+        self, hook: HookDefinition, start_time: float
+    ) -> HookResult:
+        """Create HookResult for timeout scenarios."""
+        duration = time.time() - start_time
+        return HookResult(
+            id=hook.name,
+            name=hook.name,
+            status="timeout",
+            duration=duration,
+            issues_found=[f"Hook timed out after {duration:.1f}s"],
+            stage=hook.stage.value,
+        )
+
+    def _create_error_result(
+        self, hook: HookDefinition, start_time: float, error: Exception
+    ) -> HookResult:
+        """Create HookResult for general exception scenarios."""
+        duration = time.time() - start_time
+        return HookResult(
+            id=hook.name,
+            name=hook.name,
+            status="error",
+            duration=duration,
+            issues_found=[str(error)],
+            stage=hook.stage.value,
+        )
 
     def _parse_hook_output(
         self,

crackerjack/managers/test_manager.py

@@ -136,6 +136,36 @@ class TestManager:
         except Exception:
             return None
 
+    def get_coverage(self) -> dict[str, t.Any]:
+        """Get coverage information as required by TestManagerProtocol."""
+        try:
+            # Get the ratchet status which includes coverage information
+            status = self.coverage_ratchet.get_status_report()
+
+            if status.get("status") == "not_initialized":
+                return {
+                    "status": "not_initialized",
+                    "coverage_percent": 0.0,
+                    "message": "Coverage ratchet not initialized",
+                }
+
+            return {
+                "status": "active",
+                "coverage_percent": status.get("current_coverage", 0.0),
+                "target_coverage": status.get("target_coverage", 100.0),
+                "next_milestone": status.get("next_milestone"),
+                "progress_percent": status.get("progress_percent", 0.0),
+                "last_updated": status.get("last_updated"),
+                "milestones_achieved": status.get("milestones_achieved", []),
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "coverage_percent": 0.0,
+                "error": str(e),
+                "message": "Failed to get coverage information",
+            }
+
     def has_tests(self) -> bool:
         """Check if project has tests."""
         test_directories = ["tests", "test"]
@@ -219,11 +249,17 @@ class TestManager:
                 self._handle_coverage_improvement(ratchet_result)
             return True
         else:
-            self.console.print(
-                f"[red]📉[/red] Coverage regression: "
-                f"{ratchet_result.get('current_coverage', 0):.2f}% < "
-                f"{ratchet_result.get('previous_coverage', 0):.2f}%"
-            )
+            # Use the message from the ratchet result if available, or construct from available data
+            if "message" in ratchet_result:
+                self.console.print(f"[red]📉[/red] {ratchet_result['message']}")
+            else:
+                # Fallback to constructing message from available keys
+                current = ratchet_result.get("current_coverage", 0)
+                previous = ratchet_result.get("previous_coverage", 0)
+                self.console.print(
+                    f"[red]📉[/red] Coverage regression: "
+                    f"{current:.2f}% < {previous:.2f}%"
+                )
             return False
 
     def _handle_coverage_improvement(self, ratchet_result: dict[str, t.Any]) -> None:

crackerjack/mcp/tools/workflow_executor.py

@@ -342,19 +342,20 @@ async def _execute_single_iteration(
     """Execute a single workflow iteration."""
     try:
         # Check for orchestrator workflow methods
-        if hasattr(orchestrator, "run_complete_workflow"):
-            # Standard WorkflowOrchestrator method is async
-            result = orchestrator.run_complete_workflow(options)
+        if hasattr(orchestrator, "run_complete_workflow_async"):
+            # AsyncWorkflowOrchestrator - method returns awaitable
+            result = orchestrator.run_complete_workflow_async(options)
             if result is None:
                 raise ValueError(
-                    "Method run_complete_workflow returned None instead of awaitable"
+                    "Method run_complete_workflow_async returned None instead of awaitable"
                 )
             return await result
-        elif hasattr(orchestrator, "run_complete_workflow_async"):
-            result = orchestrator.run_complete_workflow_async(options)
+        elif hasattr(orchestrator, "run_complete_workflow"):
+            # Standard WorkflowOrchestrator - method is async and returns awaitable boolean
+            result = orchestrator.run_complete_workflow(options)
             if result is None:
                 raise ValueError(
-                    "Method run_complete_workflow_async returned None instead of awaitable"
+                    "Method run_complete_workflow returned None instead of awaitable"
                 )
             return await result
         elif hasattr(orchestrator, "execute_workflow"):

crackerjack/services/coverage_ratchet.py

@@ -332,11 +332,13 @@ class CoverageRatchetService:
             # Look for .coverage file or coverage.json
             coverage_file = self.pkg_path / "coverage.json"
             if not coverage_file.exists():
-                # Look for coverage data in htmlcov/index.html or other standard locations
+                # No coverage data - this is acceptable, return success
                 return {
-                    "success": False,
-                    "error": "No coverage data found",
-                    "message": "Run tests with coverage enabled first",
+                    "success": True,
+                    "status": "no_coverage_data",
+                    "message": "No coverage data found - tests passed without coverage",
+                    "allowed": True,
+                    "baseline_updated": False,
                 }
 
             # Parse coverage data (simplified for now)
@@ -346,7 +348,9 @@ class CoverageRatchetService:
             )
 
             # Update the ratchet
-            return self.update_coverage(current_coverage)
+            result = self.update_coverage(current_coverage)
+            result["success"] = result.get("allowed", True)
+            return result
 
         except Exception as e:
             return {

crackerjack/services/git.py

@@ -29,18 +29,27 @@ class GitService:
 
     def get_changed_files(self) -> list[str]:
         try:
-            staged_result = self._run_git_command(["diff", "--cached", "--name-only"])
+            # Get staged files excluding deletions
+            staged_result = self._run_git_command(
+                ["diff", "--cached", "--name-only", "--diff-filter=ACMRT"]
+            )
             staged_files = (
                 staged_result.stdout.strip().split("\n")
                 if staged_result.stdout.strip()
                 else []
             )
-            unstaged_result = self._run_git_command(["diff", "--name-only"])
+
+            # Get unstaged files excluding deletions
+            unstaged_result = self._run_git_command(
+                ["diff", "--name-only", "--diff-filter=ACMRT"]
+            )
             unstaged_files = (
                 unstaged_result.stdout.strip().split("\n")
                 if unstaged_result.stdout.strip()
                 else []
             )
+
+            # Get untracked files
             untracked_result = self._run_git_command(
                 ["ls-files", "--others", "--exclude-standard"],
             )
@@ -49,6 +58,7 @@ class GitService:
                 if untracked_result.stdout.strip()
                 else []
             )
+
             all_files = set(staged_files + unstaged_files + untracked_files)
             return [f for f in all_files if f]
         except Exception as e:
@@ -84,22 +94,58 @@ class GitService:
                 self.console.print(f"[green]✅[/green] Committed: {message}")
                 return True
 
-            # When git commit fails due to pre-commit hooks, stderr contains hook output
-            # Use a more appropriate error message for commit failures
-            if "pre-commit" in result.stderr or "hook" in result.stderr.lower():
-                self.console.print("[red]❌[/red] Commit blocked by pre-commit hooks")
-                if result.stderr.strip():
-                    # Show hook output in a more readable way
-                    self.console.print(
-                        f"[yellow]Hook output:[/yellow]\n{result.stderr.strip()}"
-                    )
-            else:
-                self.console.print(f"[red]❌[/red] Commit failed: {result.stderr}")
-            return False
+            return self._handle_commit_failure(result, message)
         except Exception as e:
             self.console.print(f"[red]❌[/red] Error committing: {e}")
             return False
 
+    def _handle_commit_failure(
+        self, result: subprocess.CompletedProcess[str], message: str
+    ) -> bool:
+        # Check if pre-commit hooks modified files and need re-staging
+        if "files were modified by this hook" in result.stderr:
+            return self._retry_commit_after_restage(message)
+
+        return self._handle_hook_error(result)
+
+    def _retry_commit_after_restage(self, message: str) -> bool:
+        self.console.print(
+            "[yellow]🔄[/yellow] Pre-commit hooks modified files - attempting to re-stage and retry commit"
+        )
+
+        # Re-stage all modified files
+        add_result = self._run_git_command(["add", "-u"])
+        if add_result.returncode != 0:
+            self.console.print(
+                f"[red]❌[/red] Failed to re-stage files: {add_result.stderr}"
+            )
+            return False
+
+        # Retry the commit
+        retry_result = self._run_git_command(["commit", "-m", message])
+        if retry_result.returncode == 0:
+            self.console.print(
+                f"[green]✅[/green] Committed after re-staging: {message}"
+            )
+            return True
+
+        self.console.print(
+            f"[red]❌[/red] Commit failed on retry: {retry_result.stderr}"
+        )
+        return False
+
+    def _handle_hook_error(self, result: subprocess.CompletedProcess[str]) -> bool:
+        # When git commit fails due to pre-commit hooks, stderr contains hook output
+        if "pre-commit" in result.stderr or "hook" in result.stderr.lower():
+            self.console.print("[red]❌[/red] Commit blocked by pre-commit hooks")
+            if result.stderr.strip():
+                self.console.print(
+                    f"[yellow]Hook output:[/yellow]\n{result.stderr.strip()}"
+                )
+        else:
+            self.console.print(f"[red]❌[/red] Commit failed: {result.stderr}")
+        return False
+
     def push(self) -> bool:
         try:
             result = self._run_git_command(["push"])

crackerjack/services/initialization.py

@@ -72,7 +72,7 @@ class InitializationService:
             "pyproject.toml": "smart_merge",
             "CLAUDE.md": "smart_append",
             "RULES.md": "replace_if_missing",
-            "mcp.json": "special",  # Special handling: mcp.json -> .mcp.json with merging
+            "example.mcp.json": "special",  # Special handling: example.mcp.json -> .mcp.json with merging
         }
 
     def _process_config_file(
@@ -84,8 +84,8 @@ class InitializationService:
         force: bool,
         results: dict[str, t.Any],
     ) -> None:
-        # Special handling for mcp.json -> .mcp.json
-        if file_name == "mcp.json":
+        # Special handling for example.mcp.json -> .mcp.json
+        if file_name == "example.mcp.json":
             self._process_mcp_config(target_path, force, results)
             return
 
@@ -248,14 +248,14 @@ class InitializationService:
         force: bool,
         results: dict[str, t.Any],
     ) -> None:
-        """Handle special processing for mcp.json -> .mcp.json with merging."""
-        # Source: mcp.json in crackerjack package (contains servers to add to projects)
-        source_file = self.pkg_path / "mcp.json"
+        """Handle special processing for example.mcp.json -> .mcp.json with merging."""
+        # Source: example.mcp.json in crackerjack package (contains servers to add to projects)
+        source_file = self.pkg_path / "example.mcp.json"
         # Target: .mcp.json in target project
         target_file = target_path / ".mcp.json"
 
         if not source_file.exists():
-            self._handle_missing_source_file("mcp.json", results)
+            self._handle_missing_source_file("example.mcp.json", results)
             return
 
         try:
@@ -265,8 +265,8 @@ class InitializationService:
 
             if not isinstance(source_config.get("mcpServers"), dict):
                 self._handle_file_processing_error(
-                    "mcp.json",
-                    ValueError("Invalid mcp.json format: missing mcpServers"),
+                    "example.mcp.json",
+                    ValueError("Invalid example.mcp.json format: missing mcpServers"),
                     results,
                 )
                 return
@@ -543,6 +543,7 @@ python -m crackerjack -a patch
             self._smart_merge_pre_commit_config(
                 source_file,
                 target_file,
+                project_name,
                 force,
                 results,
             )
@@ -584,7 +585,7 @@ python -m crackerjack -a patch
         self._ensure_crackerjack_dev_dependency(target_config, source_config)
 
         # 2. Merge tool configurations
-        self._merge_tool_configurations(target_config, source_config)
+        self._merge_tool_configurations(target_config, source_config, project_name)
 
         # 3. Remove any fixed coverage requirements (use ratchet system instead)
         self._remove_fixed_coverage_requirements(target_config)
@@ -638,6 +639,7 @@ python -m crackerjack -a patch
         self,
         target_config: dict[str, t.Any],
         source_config: dict[str, t.Any],
+        project_name: str,
     ) -> None:
         """Merge tool configurations, preserving existing settings."""
         source_tools = source_config.get("tool", {})
@@ -662,8 +664,10 @@ python -m crackerjack -a patch
         for tool_name in tools_to_merge:
             if tool_name in source_tools:
                 if tool_name not in target_tools:
-                    # Tool missing, add it
-                    target_tools[tool_name] = source_tools[tool_name]
+                    # Tool missing, add it with project-name replacement
+                    target_tools[tool_name] = self._replace_project_name_in_tool_config(
+                        source_tools[tool_name], project_name
+                    )
                     self.console.print(
                         f"[green]➕[/green] Added [tool.{tool_name}] configuration",
                     )
@@ -673,6 +677,7 @@ python -m crackerjack -a patch
                         target_tools[tool_name],
                         source_tools[tool_name],
                         tool_name,
+                        project_name,
                     )
 
         # Special handling for pytest.ini_options markers
@@ -683,13 +688,16 @@ python -m crackerjack -a patch
         target_tool: dict[str, t.Any],
         source_tool: dict[str, t.Any],
         tool_name: str,
+        project_name: str,
     ) -> None:
         """Merge individual tool settings."""
         updated_keys = []
 
         for key, value in source_tool.items():
             if key not in target_tool:
-                target_tool[key] = value
+                target_tool[key] = self._replace_project_name_in_config_value(
+                    value, project_name
+                )
                 updated_keys.append(key)
 
         if updated_keys:
@@ -779,6 +787,7 @@ python -m crackerjack -a patch
         self,
         source_file: Path,
         target_file: Path,
+        project_name: str,
         force: bool,
         results: dict[str, t.Any],
     ) -> None:
@@ -788,8 +797,12 @@ python -m crackerjack -a patch
             source_config = yaml.safe_load(f)
 
         if not target_file.exists():
-            # No existing file, just copy with proper formatting
-            content = source_file.read_text()
+            # No existing file, copy with project-specific replacements
+            content = self._read_and_process_content(
+                source_file,
+                True,  # should_replace
+                project_name,
+            )
             # Clean trailing whitespace and ensure single trailing newline
             from crackerjack.services.filesystem import FileSystemService
 
@@ -871,3 +884,39 @@ python -m crackerjack -a patch
             )
         else:
             self._skip_existing_file(".pre-commit-config.yaml (no new repos)", results)
+
+    def _replace_project_name_in_tool_config(
+        self, tool_config: dict[str, t.Any], project_name: str
+    ) -> dict[str, t.Any]:
+        """Replace project name in entire tool configuration."""
+        if project_name == "crackerjack":
+            return tool_config  # No replacement needed
+
+        # Deep copy to avoid modifying original
+        import copy
+
+        result = copy.deepcopy(tool_config)
+
+        # Recursively replace in the configuration
+        return self._replace_project_name_in_config_value(result, project_name)
+
+    def _replace_project_name_in_config_value(
+        self, value: t.Any, project_name: str
+    ) -> t.Any:
+        """Replace project name in a configuration value (recursive)."""
+        if project_name == "crackerjack":
+            return value  # No replacement needed
+
+        if isinstance(value, str):
+            return value.replace("crackerjack", project_name)
+        elif isinstance(value, list):
+            return [
+                self._replace_project_name_in_config_value(item, project_name)
+                for item in value
+            ]
+        elif isinstance(value, dict):
+            return {
+                key: self._replace_project_name_in_config_value(val, project_name)
+                for key, val in value.items()
+            }
+        return value  # Numbers, booleans, etc. - no replacement needed

{crackerjack-0.31.8.dist-info → crackerjack-0.31.10.dist-info}/METADATA

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

{crackerjack-0.31.8.dist-info → crackerjack-0.31.10.dist-info}/RECORD

@@ -32,19 +32,19 @@ crackerjack/cli/utils.py,sha256=VHR-PALgA8fsKiPytH0cl8feXrtWKCajjk9TS2piK5w,537
 crackerjack/config/__init__.py,sha256=b0481N2f_JvGufMPcbo5IXu2VjYd111r1BHw0oD3x7o,330
 crackerjack/config/hooks.py,sha256=6DHJkWRL5c5Ip2bw0tevRt_xzRFKSfeO7tQkGtoZtjs,5367
 crackerjack/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-crackerjack/core/async_workflow_orchestrator.py,sha256=XCy_5L2xTRZaGHjO_ysuMV7WuMgRgLsSXiqBJO_nyXE,15069
+crackerjack/core/async_workflow_orchestrator.py,sha256=r7E-F6hv5MvhcYFB2VB1HgBaOgDJZJXIGN9DCXk4pmo,21660
 crackerjack/core/autofix_coordinator.py,sha256=txbXTeGm-gJwuyRekVDbvvKgG0gQ1GqB3BeGdQ8vqpY,7921
 crackerjack/core/container.py,sha256=e9_1YnWHijUJ0yl23lpgf9mennVQy8NkgJBKtZstG-M,2889
 crackerjack/core/enhanced_container.py,sha256=fl5XvhNY0fzDnD5hSr16yQXGtL_AW01Wf4F4PL1L0P4,18169
 crackerjack/core/performance.py,sha256=sL9g2-_JflofnsXW6LUCwp9MaUDQprfV8lSG18s9mns,7601
-crackerjack/core/phase_coordinator.py,sha256=iWPVB3A5CFfHwqc3wFXGEQwBhzaa-VlGsvhvRid5FKE,21236
+crackerjack/core/phase_coordinator.py,sha256=L0-OXrxNDfcqSQnhyaeXot1fDk_zdHEWBl-thcbz65Y,21244
 crackerjack/core/proactive_workflow.py,sha256=ML1amNJI4Gx0dFJK5AKdvB0zNc1chbq-ZyqnhUi4tms,12677
 crackerjack/core/session_coordinator.py,sha256=hJKLthZBzX7fXm8AmNMFLEjITNmKxDGqM58Om6p7fr0,9893
-crackerjack/core/workflow_orchestrator.py,sha256=eQl4y5ni0ajVuwtZf4z5cmsi10aTs-k7nVcEBgDHNEo,31412
+crackerjack/core/workflow_orchestrator.py,sha256=YHG-qp8J76fqj_poGRvTvuimljbJBvVwPT1r1OjF95M,38459
 crackerjack/executors/__init__.py,sha256=HF-DmXvKN45uKKDdiMxOT9bYxuy1B-Z91BihOhkK5lg,322
 crackerjack/executors/async_hook_executor.py,sha256=3U-AHToGNBojnlDsXK6HLv4CfJvv64UqTmCWYAoLcb8,15958
 crackerjack/executors/cached_hook_executor.py,sha256=LyrFINWbixB-0xEnaU0F2ZUBFUWrAdaTKvj_JW1Wss0,8186
-crackerjack/executors/hook_executor.py,sha256=uZ78CSaYXBRKOyHVlT9w_YW4u09vRxI1zHfWohkumtI,12020
+crackerjack/executors/hook_executor.py,sha256=chdZg_DdPRq4q8P0Ed7v2L5q2X6Z9HVZsXfwVf0oj1I,13608
 crackerjack/executors/individual_hook_executor.py,sha256=Fm58XlKtGAzTvkvFIOv7ILmN01QQy6QQeScKZ84mgFw,23526
 crackerjack/intelligence/__init__.py,sha256=v5ovNZ9jLENYp4sizRINqxLw63b23lvzg6bGk8d0s-M,1106
 crackerjack/intelligence/adaptive_learning.py,sha256=VvOAYAEyuKvwSwhSOikuVgGlwSpOzvtaJFIkJuemQtQ,28687
@@ -58,7 +58,7 @@ crackerjack/managers/hook_manager.py,sha256=3qAKLYqoJGPJ8NAUB1KEoWHZafjs6564P9ud
 crackerjack/managers/publish_manager.py,sha256=7bBXkaHm1Ou-tMLvUqNQZScp_onZ2SJgB0o3kwThUDE,16084
 crackerjack/managers/test_command_builder.py,sha256=MdDz9AYSLOoLmI-8zoq3zd2SXF3DeuIkANa76h9cINI,5295
 crackerjack/managers/test_executor.py,sha256=XCMuJPssTV2Glb0hDPHvoDbVrJHVJpZrsAIltegMMfE,16337
-crackerjack/managers/test_manager.py,sha256=BqCaMCUhXx_MJV8CmqXQ-54gZErfdCU5ejgvps4vXPo,9735
+crackerjack/managers/test_manager.py,sha256=4HfnkWy2Sqbu-YW9zkIK0UNc1bnk0SUspK0ldg5RFGI,11387
 crackerjack/managers/test_manager_backup.py,sha256=tptpX99nw-caLJMVga4Hss7grJRqcFHz1JkRBqro4sE,41307
 crackerjack/managers/test_progress.py,sha256=gCNKdE7Bh7RS3K7Ekj2MGKCqiY4px54AzPNi0gMhAL0,3908
 crackerjack/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -88,7 +88,7 @@ crackerjack/mcp/tools/monitoring_tools.py,sha256=tcMIc0-qj35QbQp-5fNM47tnyLmjieY
 crackerjack/mcp/tools/proactive_tools.py,sha256=0ax3clOEJ9yoHTTnvE3IFoutjoDZIpvFgIBowL6ANfU,14067
 crackerjack/mcp/tools/progress_tools.py,sha256=l9MzVRUxO19FNpHn67zWbhyUeXyJOVxlnAQLJiVJBIg,6822
 crackerjack/mcp/tools/utility_tools.py,sha256=MIv1CGR8vLeQEdKzR8xsNYj5A9TG_LXWp86drdKReXY,11849
-crackerjack/mcp/tools/workflow_executor.py,sha256=_bA8lNV5ywxPVmSM_PY4NzdTUY3FH9ddHnPkrrFqksU,17756
+crackerjack/mcp/tools/workflow_executor.py,sha256=JQSWmhxQBL4p7AwHUcBYBfbCBEGFO7OSyQFAKYuD0uM,17855
 crackerjack/mcp/websocket/__init__.py,sha256=lZzyfvYjywHfqyy5X3wWR_jgBkRUxYSpgjdKALBzZcI,345
 crackerjack/mcp/websocket/app.py,sha256=AXijAplfW-8NwWDrOON30Ol5qcMKdc64npTY2YEkX8s,1193
 crackerjack/mcp/websocket/endpoints.py,sha256=L5zZzqhZtLFKF-Eh928jnwQIAIwunBSMrIaBoyaOaAE,20888
@@ -117,15 +117,15 @@ crackerjack/services/cache.py,sha256=LKZIa8xZ6SzwdTBttO1W6VEBxaTgMNI5Paz_IgrqoaI
 crackerjack/services/config.py,sha256=BrIJoKKi0qyQg2lcZZhTTUpAVB6ej6gkbPv95o2rVvc,14050
 crackerjack/services/config_integrity.py,sha256=wn6b0x90wXNRSj64J_kOQ5JMQvG_9FwtOno0ITVJGwM,3416
 crackerjack/services/contextual_ai_assistant.py,sha256=QnJvJNdGimk-u6XxPm9D7F516AmbueNnAmky42D2caQ,19206
-crackerjack/services/coverage_ratchet.py,sha256=i12mOg5kB2iU3i4hn0LVLcVXJSPkBorO6Xu_nIiGrfs,13567
+crackerjack/services/coverage_ratchet.py,sha256=XM4iCe_Bckh1j378FgAG2zlbiJNCF0VeH1qVWG-fu1s,13731
 crackerjack/services/debug.py,sha256=crjsUZwVjP92aCEOEmtpEJwNf5gtlwNeZF_eB9JSfiI,24018
 crackerjack/services/dependency_monitor.py,sha256=axBXFGBdezoPK9ph5_ZGxIwhSJhurgdvCSiuaCWSrKY,21085
 crackerjack/services/enhanced_filesystem.py,sha256=MQj5zqvkNc5U6ZUmSVzgFQWKfnizD1lv4SJ2pt-w8W4,15424
 crackerjack/services/file_hasher.py,sha256=vHSJ6QbWU5Q5JPLYuQkyRMRXCpDC_hsxToaM83vI58U,5201
 crackerjack/services/filesystem.py,sha256=Re5VyP7H8W6T2tpDakoaghEivdR2VmshJgnZ9Y3QkH8,17932
-crackerjack/services/git.py,sha256=uR5uNnyW9mkOz_fRzJkhLQWErEV4ATtJLhIeX4MYMFE,7105
+crackerjack/services/git.py,sha256=ZsIrsYhTuDyRSz4Lhtvh2cEFose7EPSpuDg74Vh8npI,8613
 crackerjack/services/health_metrics.py,sha256=M2OBqwwnGvnJB3eXIXXh5SgMuckYCjHIrD0RkYFAbQU,21458
-crackerjack/services/initialization.py,sha256=iNXGn1OEVKfGNJAJXdqjcqGKvvXFKdaVfrDMnyTBAtw,31476
+crackerjack/services/initialization.py,sha256=l3CagjRvBD9AQWkzD_JWQciSCQpYOPduRkPdUprE6MA,33455
 crackerjack/services/log_manager.py,sha256=deM_i97biZVyuZJoHaGlnBitc5QV4WaaZHEb70N5LV0,8388
 crackerjack/services/logging.py,sha256=c15gVCLR_yRhqaza7f1pLLYL-xQ3Oi_OMWL_mR5G46k,5354
 crackerjack/services/metrics.py,sha256=kInkb2G0ML8hAtmEG1jK04b-F1hT_fZjHvYJKisyr1Y,22894
@@ -142,8 +142,8 @@ crackerjack/slash_commands/__init__.py,sha256=ZHfKjluj9dX88zDYN6Saj7tGUMdMnh37Q8
 crackerjack/slash_commands/init.md,sha256=mANRdCiFAzaTw29lKNrI1JFthK4pxVdtiFC5lN2SDSQ,4581
 crackerjack/slash_commands/run.md,sha256=bf_mEtnXagUuw3w8os5h3t1Yi3vjpfiNbkMJvuFEu-Y,6500
 crackerjack/slash_commands/status.md,sha256=U3qqppVLtIIm2lEiMYaKagaHYLI9UplL7OH1j6SRJGw,3921
-crackerjack-0.31.8.dist-info/METADATA,sha256=IoaiWGfqr7QWW5nPAVCq0taM0qHya4yh8UU4ptfHLso,22437
-crackerjack-0.31.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-crackerjack-0.31.8.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
-crackerjack-0.31.8.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
-crackerjack-0.31.8.dist-info/RECORD,,
+crackerjack-0.31.10.dist-info/METADATA,sha256=4VBwoRFPEEXi1M6Lh6wY7wCEFTAmVKnyRowdCjDT4V8,22438
+crackerjack-0.31.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+crackerjack-0.31.10.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
+crackerjack-0.31.10.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
+crackerjack-0.31.10.dist-info/RECORD,,