crackerjack 0.31.8__tar.gz → 0.31.9__tar.gz

crackerjack-0.31.9/CHANGELOG.md

@@ -0,0 +1,302 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [Unreleased] - 2025-09-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
+## [0.31.8] - 2025-09-01
+
+### Fixed
+
+- Critical bug in AI agent workflow where specific error details were not being captured from hook failures
+- Fixed `HookExecutor` to properly capture subprocess output in `issues_found` field
+- Fixed `AsyncWorkflowOrchestrator._collect_comprehensive_hook_issues_async()` to extract specific issues from `HookResult.issues_found`
+- Fixed `_collect_test_issues_async()` to use `test_manager.get_test_failures()` for detailed error information
+- Connected `_apply_ai_fixes_async()` to existing `AgentCoordinator` system for structured issue processing
+- Added `_parse_issues_for_agents()` method to convert string issues to structured `Issue` objects
+- Resolved pyright type errors in async workflow orchestrator
+
+### Improved
+
+- Enhanced AI agent error collection to provide specific details instead of generic messages
+- Improved iterative fixing workflow to process all collected issues in batch rather than stopping on first failure
+- Better integration between hook execution and AI agent fixing phases
+
+## [0.31.7] - 2025-09-01
+
+### Added
+
+- Enhanced configuration management and dependency updates
+- Improved core workflow orchestration patterns
+
+### Fixed
+
+- Configuration consistency across different execution modes
+- Core dependency management improvements
+
+## [0.31.6] - 2025-09-01
+
+### Added
+
+- Documentation updates for AI agent workflow rules
+- Enhanced configuration management for modular architecture
+
+### Fixed
+
+- Core workflow improvements and configuration consistency
+- Documentation accuracy for recent architectural changes
+
+## [0.31.5] - 2025-09-01
+
+### Added
+
+- Comprehensive AI agent workflow documentation (AI-AGENT-RULES.md)
+- Detailed iteration protocol specifications for AI agent fixing
+- Sub-agent architecture documentation with 9 specialized agents
+- Enhanced error collection and batch fixing patterns
+
+### Fixed
+
+- AI agent workflow iteration boundaries and fix application timing
+- Progress validation between iterations
+- WebSocket progress reporting for MCP server integration
+
+## [0.31.4] - 2025-09-01
+
+### Added
+
+- Modular MCP server architecture (70% line reduction from 3,116 to 921 lines)
+- WebSocket server refactoring (35% reduction from 1,479 to 944 lines)
+- Enhanced filesystem operations with XDG compliance and atomic operations
+- Plugin system architecture with dynamic loading and dependency resolution
+
+### Fixed
+
+- CLI entry point complexity reduction (80% reduction from 601 to 122 lines)
+- Protocol-based dependency injection improvements
+- Thread-safe session state management with async locks
+- Service lifecycle management with enhanced container patterns
+
+## [0.31.3] - 2025-09-01
+
+### Added
+
+- Enhanced container with service lifetime management (SINGLETON, TRANSIENT, SCOPED)
+- Advanced filesystem operations with backup management and security validation
+- Comprehensive health metrics and performance benchmarking
+- Plugin-based hook system with custom validation rules
+
+### Fixed
+
+- Service descriptor with factory support and dependency resolution
+- Thread-local scoping for singleton services
+- Circular dependency detection in enhanced container
+- Performance monitoring for file operations
+
+## [0.31.0] - 2025-08-31
+
+### Added
+
+- Major architectural refactoring from monolithic to modular design
+- Dependency injection container with protocol-based interfaces
+- Advanced workflow orchestration with parallel execution strategies
+- Session coordination with cleanup handlers and progress management
+- Comprehensive manager pattern for hook, test, and publish operations
+
+### Changed
+
+- **BREAKING**: Migrated from monolithic `Crackerjack` class to modular `WorkflowOrchestrator`
+- Restructured CLI interface with dedicated options and handlers modules
+- Enhanced async/await patterns throughout the codebase
+- Protocol-based interfaces in `models/protocols.py` for better testability
+
+### Fixed
+
+- All 31+ refurb violations in agents directory (FURB107, FURB109, FURB118, etc.)
+- Major complexity reductions in critical functions (34→3, 33→2)
+- Import error prevention with proper protocol usage
+- Fast hooks consistency and reliability improvements
+
+## [0.30.3] - 2025-08-29
+
+### Added
+
+- Coverage ratchet system targeting 100% test coverage
+- Milestone celebration system for coverage achievements
+- Progressive coverage improvement with no regression policy
+- Enhanced test management with intelligent parallelization
+
+### Changed
+
+- Replaced arbitrary coverage limits with continuous improvement model
+- Enhanced testing framework with timeout and worker configuration
+- Rich terminal displays for coverage progress visualization
+
+### Fixed
+
+- Test execution reliability and performance optimization
+- Coverage measurement accuracy and consistency
+- Memory usage optimization for large test suites
+
+## [0.30.2] - 2025-08-29
+
+### Added
+
+- AI agent integration with MCP (Model Context Protocol) server
+- WebSocket-based progress streaming for real-time monitoring
+- Comprehensive pre-commit hook management with fast/comprehensive stages
+- Service watchdog for automatic MCP and WebSocket server monitoring
+
+### Changed
+
+- Enhanced CLI with AI agent mode and interactive Rich UI
+- Improved error handling and structured output for AI agents
+- Advanced workflow orchestration with session coordination
+
+### Fixed
+
+- MCP server stability and connection handling
+- WebSocket progress reporting accuracy
+- Pre-commit hook execution reliability and performance
+
+______________________________________________________________________
+
+## Historical Context
+
+This changelog was reconstructed from git history on 2025-09-02. Prior to v0.30.2, Crackerjack underwent significant development including:
+
+- Initial Python project management tool creation
+- UV package manager integration
+- Ruff, pytest, and pre-commit hook unification
+- Basic quality enforcement workflow implementation
+- Foundation for modular architecture patterns
+
+For detailed commit history, use: `git log --oneline --since="2025-08-01"`
+
+## Contributing
+
+When updating this changelog:
+
+1. Follow [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format
+1. Group changes under Added, Changed, Deprecated, Removed, Fixed, Security
+1. Include version numbers and dates for all releases
+1. Link to relevant issues and pull requests when applicable
+1. Focus on user-facing changes rather than internal refactoring details
+
+## Version Links
+
+- \[0.31.8\]: Latest release with AI agent workflow fixes
+- \[0.31.0\]: Major architectural refactoring to modular design
+- \[0.30.3\]: Coverage ratchet system introduction
+- \[0.30.2\]: AI agent and MCP server integration

{crackerjack-0.31.8 → crackerjack-0.31.9}/PKG-INFO

@@ -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 → crackerjack-0.31.9}/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: