crackerjack 0.31.8__py3-none-any.whl → 0.31.9__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/workflow_orchestrator.py

@@ -62,74 +62,113 @@ 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)
@@ -560,6 +599,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 +792,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/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/git.py

@@ -84,22 +84,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

@@ -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.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.31.8
+Version: 0.31.9
 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.9.dist-info}/RECORD

@@ -32,7 +32,7 @@ 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
@@ -40,11 +40,11 @@ crackerjack/core/performance.py,sha256=sL9g2-_JflofnsXW6LUCwp9MaUDQprfV8lSG18s9m
 crackerjack/core/phase_coordinator.py,sha256=iWPVB3A5CFfHwqc3wFXGEQwBhzaa-VlGsvhvRid5FKE,21236
 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=YfqnVartb7qIHEF5qRpy_Fw1ViyICfBf2r0Le9UCiIM,37749
 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
@@ -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
@@ -123,9 +123,9 @@ crackerjack/services/dependency_monitor.py,sha256=axBXFGBdezoPK9ph5_ZGxIwhSJhurg
 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=Jth_GiufRkEkUACUyOXELVx92CUXoPAdW5_6G-Mr8Sc,8366
 crackerjack/services/health_metrics.py,sha256=M2OBqwwnGvnJB3eXIXXh5SgMuckYCjHIrD0RkYFAbQU,21458
-crackerjack/services/initialization.py,sha256=iNXGn1OEVKfGNJAJXdqjcqGKvvXFKdaVfrDMnyTBAtw,31476
+crackerjack/services/initialization.py,sha256=xcMqZmIi6pKufwYksJI17Tl7bZ7X7tOLqzNW7cvVZhg,33375
 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.9.dist-info/METADATA,sha256=Y15hY2DSOtPmmEzByI4qpJBfAjPAg2GdnGxCj8SoEvw,22437
+crackerjack-0.31.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+crackerjack-0.31.9.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
+crackerjack-0.31.9.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
+crackerjack-0.31.9.dist-info/RECORD,,