crackerjack 0.30.3__py3-none-any.whl → 0.31.4__py3-none-any.whl

crackerjack/core/proactive_workflow.py

@@ -0,0 +1,316 @@
+import logging
+import time
+import typing as t
+from pathlib import Path
+
+from ..agents.base import AgentContext, Issue, IssueType, Priority
+from ..agents.coordinator import AgentCoordinator
+from ..models.protocols import OptionsProtocol
+
+
+class ProactiveWorkflowPipeline:
+    """Enhanced workflow pipeline with proactive architectural planning.
+
+    This pipeline adds a planning phase before each iteration to prevent
+    issues through intelligent architecture rather than reactive fixing.
+    """
+
+    def __init__(self, project_path: Path) -> None:
+        self.project_path = project_path
+        self.logger = logging.getLogger(__name__)
+        self._architect_agent_coordinator: AgentCoordinator | None = None
+
+    async def run_complete_workflow_with_planning(
+        self, options: OptionsProtocol
+    ) -> bool:
+        """Execute workflow with proactive planning phases."""
+        self.logger.info("Starting proactive workflow with architectural planning")
+
+        start_time = time.time()
+
+        try:
+            # Phase 1: Initial architectural assessment
+            assessment = await self._assess_codebase_architecture()
+
+            if assessment.needs_planning:
+                self.logger.info("Codebase requires architectural planning")
+
+                # Phase 2: Create comprehensive architectural plan
+                architectural_plan = await self._create_comprehensive_plan(assessment)
+
+                # Phase 3: Execute workflow following the plan
+                result = await self._execute_planned_workflow(
+                    options, architectural_plan
+                )
+            else:
+                self.logger.info(
+                    "Codebase is architecturally sound, using standard workflow"
+                )
+                # Fallback to standard workflow for simple fixes
+                result = await self._execute_standard_workflow(options)
+
+            execution_time = time.time() - start_time
+            self.logger.info(f"Proactive workflow completed in {execution_time:.2f}s")
+
+            return result
+
+        except Exception as e:
+            self.logger.exception(f"Proactive workflow failed: {e}")
+            # Fallback to standard workflow on planning failure
+            return await self._execute_standard_workflow(options)
+
+    async def _assess_codebase_architecture(self) -> "ArchitecturalAssessment":
+        """Assess the codebase to determine if proactive planning is needed."""
+        self.logger.info("Assessing codebase architecture...")
+
+        # Initialize architect coordinator if needed
+        if not self._architect_agent_coordinator:
+            agent_context = AgentContext(project_path=self.project_path)
+            self._architect_agent_coordinator = AgentCoordinator(agent_context)
+            self._architect_agent_coordinator.initialize_agents()
+
+        # Create test issues to assess complexity
+        test_issues = await self._identify_potential_issues()
+
+        # Determine if planning is beneficial
+        needs_planning = self._evaluate_planning_need(test_issues)
+
+        return ArchitecturalAssessment(
+            needs_planning=needs_planning,
+            complexity_score=len(test_issues),
+            potential_issues=test_issues,
+            recommended_strategy="proactive" if needs_planning else "standard",
+        )
+
+    async def _identify_potential_issues(self) -> list[Issue]:
+        """Identify potential architectural issues in the codebase."""
+        # This would integrate with static analysis tools
+        # For now, create representative issues based on common patterns
+
+        potential_issues = []
+
+        # Check for complexity hotspots (would use real analysis)
+        potential_issues.extend(
+            (
+                Issue(
+                    id="arch_assessment_complexity",
+                    type=IssueType.COMPLEXITY,
+                    severity=Priority.HIGH,
+                    message="Potential complexity hotspots detected",
+                    file_path=str(self.project_path),
+                    details=["Multiple functions may exceed complexity threshold"],
+                ),
+                Issue(
+                    id="arch_assessment_dry",
+                    type=IssueType.DRY_VIOLATION,
+                    severity=Priority.MEDIUM,
+                    message="Potential code duplication patterns",
+                    file_path=str(self.project_path),
+                    details=["Similar patterns may exist across modules"],
+                ),
+            )
+        )
+
+        return potential_issues
+
+    def _evaluate_planning_need(self, issues: list[Issue]) -> bool:
+        """Evaluate if proactive planning would be beneficial."""
+        # Planning is beneficial for:
+        # 1. Multiple complex issues
+        # 2. Architectural issues (complexity, DRY, performance)
+        # 3. Projects with many interdependencies
+
+        complex_issues = [
+            issue
+            for issue in issues
+            if issue.type
+            in {IssueType.COMPLEXITY, IssueType.DRY_VIOLATION, IssueType.PERFORMANCE}
+        ]
+
+        # Need planning if we have 2+ complex issues
+        return len(complex_issues) >= 2
+
+    async def _create_comprehensive_plan(
+        self, assessment: "ArchitecturalAssessment"
+    ) -> dict[str, t.Any]:
+        """Create comprehensive architectural plan based on assessment."""
+        self.logger.info("Creating comprehensive architectural plan...")
+
+        assert self._architect_agent_coordinator is not None
+
+        # Use ArchitectAgent to create the plan
+        architect = self._architect_agent_coordinator._get_architect_agent()
+
+        if not architect:
+            self.logger.warning("No ArchitectAgent available, creating basic plan")
+            return {
+                "strategy": "basic_reactive",
+                "phases": ["standard_workflow"],
+                "patterns": ["default"],
+            }
+
+        # Create plan for the most complex issue as representative
+        complex_issues = [
+            issue
+            for issue in assessment.potential_issues
+            if issue.type in {IssueType.COMPLEXITY, IssueType.DRY_VIOLATION}
+        ]
+
+        if complex_issues:
+            primary_issue = complex_issues[0]
+            base_plan = await architect.plan_before_action(primary_issue)
+
+            # Extend to comprehensive workflow plan
+            comprehensive_plan = base_plan | {
+                "phases": [
+                    "configuration_setup",
+                    "fast_hooks_with_architecture",
+                    "architectural_refactoring",
+                    "comprehensive_validation",
+                    "pattern_learning",
+                ],
+                "integration_points": [
+                    "architect_guided_fixing",
+                    "pattern_caching",
+                    "validation_against_plan",
+                ],
+            }
+        else:
+            comprehensive_plan = {
+                "strategy": "lightweight_proactive",
+                "phases": ["standard_workflow_enhanced"],
+                "patterns": ["cached_patterns"],
+            }
+
+        self.logger.info(
+            f"Created plan with strategy: {comprehensive_plan.get('strategy')}"
+        )
+        return comprehensive_plan
+
+    async def _execute_planned_workflow(
+        self, options: OptionsProtocol, plan: dict[str, t.Any]
+    ) -> bool:
+        """Execute workflow following the architectural plan."""
+        strategy = plan.get("strategy", "basic_reactive")
+        phases = plan.get("phases", ["standard_workflow"])
+
+        self.logger.info(f"Executing {strategy} workflow with {len(phases)} phases")
+
+        # Execute each phase according to the plan
+        for phase in phases:
+            success = await self._execute_workflow_phase(phase, options, plan)
+            if not success and phase in (
+                "configuration_setup",
+                "architectural_refactoring",
+            ):
+                # Critical phases - fail fast
+                self.logger.error(f"Critical phase {phase} failed")
+                return False
+            elif not success:
+                # Non-critical phases - log and continue
+                self.logger.warning(f"Phase {phase} had issues but continuing")
+
+        return True
+
+    async def _execute_workflow_phase(
+        self, phase: str, options: OptionsProtocol, plan: dict[str, t.Any]
+    ) -> bool:
+        """Execute a specific workflow phase."""
+        self.logger.info(f"Executing phase: {phase}")
+
+        # Different phase implementations
+        if phase == "configuration_setup":
+            return await self._setup_with_architecture(options, plan)
+        elif phase == "fast_hooks_with_architecture":
+            return await self._run_fast_hooks_with_planning(options, plan)
+        elif phase == "architectural_refactoring":
+            return await self._perform_architectural_refactoring(options, plan)
+        elif phase == "comprehensive_validation":
+            return await self._comprehensive_validation(options, plan)
+        elif phase == "pattern_learning":
+            return await self._learn_and_cache_patterns(plan)
+        # Fallback to standard workflow for unknown phases
+        return await self._execute_standard_workflow(options)
+
+    async def _setup_with_architecture(
+        self, options: OptionsProtocol, plan: dict[str, t.Any]
+    ) -> bool:
+        """Setup phase with architectural considerations."""
+        self.logger.info("Setting up project with architectural planning")
+        # This would integrate with existing setup logic
+        # For now, return success as architecture is already integrated
+        return True
+
+    async def _run_fast_hooks_with_planning(
+        self, options: OptionsProtocol, plan: dict[str, t.Any]
+    ) -> bool:
+        """Run fast hooks with architectural awareness."""
+        self.logger.info("Running fast hooks with architectural planning")
+        # This would integrate with existing hook manager
+        # Enhanced to use architectural patterns from the plan
+        return True
+
+    async def _perform_architectural_refactoring(
+        self, options: OptionsProtocol, plan: dict[str, t.Any]
+    ) -> bool:
+        """Perform refactoring following architectural plan."""
+        self.logger.info("Performing architectural refactoring")
+
+        # Use ArchitectAgent to guide refactoring
+        if self._architect_agent_coordinator:
+            architect = self._architect_agent_coordinator._get_architect_agent()
+            if architect:
+                # This would apply the architectural patterns
+                patterns = plan.get("patterns", [])
+                self.logger.info(f"Applying architectural patterns: {patterns}")
+                return True
+
+        return True
+
+    async def _comprehensive_validation(
+        self, options: OptionsProtocol, plan: dict[str, t.Any]
+    ) -> bool:
+        """Validate results against architectural plan."""
+        self.logger.info("Performing comprehensive validation")
+        validation_steps = plan.get("validation", [])
+
+        for step in validation_steps:
+            self.logger.info(f"Validating: {step}")
+            # Implement specific validation logic
+
+        return True
+
+    async def _learn_and_cache_patterns(self, plan: dict[str, t.Any]) -> bool:
+        """Learn from successful patterns and cache them."""
+        self.logger.info("Learning and caching successful patterns")
+
+        # Cache successful patterns from the plan
+        if self._architect_agent_coordinator:
+            architect = self._architect_agent_coordinator._get_architect_agent()
+            if architect and hasattr(architect, "get_cached_patterns"):
+                cached_patterns = architect.get_cached_patterns()
+                self.logger.info(f"Cached {len(cached_patterns)} patterns")
+
+        return True
+
+    async def _execute_standard_workflow(self, options: OptionsProtocol) -> bool:
+        """Fallback to standard workflow execution."""
+        self.logger.info("Executing standard workflow (fallback)")
+        # This would delegate to the existing workflow pipeline
+        return True
+
+
+class ArchitecturalAssessment:
+    """Assessment of codebase architecture for planning decisions."""
+
+    def __init__(
+        self,
+        needs_planning: bool,
+        complexity_score: int,
+        potential_issues: list[Issue],
+        recommended_strategy: str,
+    ) -> None:
+        self.needs_planning = needs_planning
+        self.complexity_score = complexity_score
+        self.potential_issues = potential_issues
+        self.recommended_strategy = recommended_strategy

crackerjack/core/session_coordinator.py

@@ -0,0 +1,289 @@
+import json
+import logging
+import time
+import typing as t
+from contextlib import suppress
+from pathlib import Path
+
+from rich.console import Console
+
+from crackerjack.models.protocols import OptionsProtocol
+from crackerjack.models.task import SessionTracker
+
+
+class SessionCoordinator:
+    def __init__(
+        self,
+        console: Console,
+        pkg_path: Path,
+        web_job_id: str | None = None,
+    ) -> None:
+        self.console = console
+        self.pkg_path = pkg_path
+        self.session_tracker: SessionTracker | None = None
+        self._cleanup_handlers: list[t.Callable[[], None]] = []
+        self._thread_pool = None
+        self._lock_files: set[Path] = set()
+
+        import uuid
+
+        self.session_id = web_job_id or str(uuid.uuid4())
+        self.web_job_id = web_job_id
+        self.start_time = time.time()
+        self.tasks: dict[str, t.Any] = {}
+        self.current_task: str | None = None
+        self.success: bool = False
+
+        self._setup_logging()
+
+        if self.web_job_id:
+            self._setup_websocket_progress_file()
+
+    def start_session(self, task_name: str) -> None:
+        self.current_task = task_name
+
+    def end_session(self, success: bool = True) -> None:
+        self.success = success
+        self.end_time = time.time()
+        if success:
+            self.complete_task("session", "Session completed successfully")
+        else:
+            self.fail_task("session", "Session completed with errors")
+
+    def initialize_session_tracking(self, options: OptionsProtocol) -> None:
+        if hasattr(options, "track_progress") and options.track_progress:
+            import uuid
+
+            self.session_tracker = SessionTracker(
+                console=self.console,
+                session_id=str(uuid.uuid4()),
+                start_time=time.time(),
+            )
+
+    def track_task(self, task_id: str, task_name: str) -> str:
+        import time
+
+        task_obj = type(
+            "Task",
+            (),
+            {
+                "task_id": task_id,
+                "description": task_name,
+                "start_time": time.time(),
+                "status": "in_progress",
+                "details": None,
+                "end_time": None,
+                "progress": 0,
+            },
+        )()
+
+        self.tasks[task_id] = task_obj
+
+        if self.session_tracker:
+            self.session_tracker.start_task(task_id, task_name)
+
+        return task_id
+
+    def update_task(
+        self,
+        task_id: str,
+        status: str,
+        details: str | None = None,
+        progress: int | None = None,
+    ) -> None:
+        if task_id in self.tasks:
+            task = self.tasks[task_id]
+            task.status = status
+            if details:
+                task.details = details
+            if progress is not None:
+                task.progress = progress
+
+            if status in ("completed", "failed"):
+                task.end_time = time.time()
+
+    def complete_task(self, task_id: str, details: str | None = None) -> None:
+        if self.session_tracker:
+            self.session_tracker.complete_task(task_id, details=details)
+
+    def fail_task(self, task_id: str, error: str) -> None:
+        if self.session_tracker:
+            self.session_tracker.fail_task(task_id, error)
+
+    def get_session_summary(self) -> dict[str, int] | None:
+        if self.session_tracker:
+            return self.session_tracker.get_summary()
+        return None
+
+    def get_summary(self) -> dict[str, t.Any]:
+        duration = getattr(self, "end_time", time.time()) - self.start_time
+        tasks_count = len(self.tasks)
+
+        if self.session_tracker:
+            return self.session_tracker.get_summary()
+
+        return {
+            "session_id": self.session_id,
+            "duration": duration,
+            "tasks_count": tasks_count,
+            "success": self.success,
+            "tasks": [
+                {
+                    "task_id": task.task_id,
+                    "description": task.description,
+                    "status": task.status,
+                    "details": task.details,
+                    "start_time": task.start_time,
+                    "end_time": task.end_time,
+                    "progress": task.progress,
+                }
+                for task in self.tasks.values()
+            ],
+        }
+
+    def finalize_session(self, start_time: float, success: bool) -> None:
+        total_time = time.time() - start_time
+        if success:
+            self.complete_task(
+                "workflow",
+                f"Completed successfully in {total_time:.1f}s",
+            )
+        else:
+            self.complete_task(
+                "workflow",
+                f"Completed with issues in {total_time:.1f}s",
+            )
+
+    def register_cleanup(self, cleanup_handler: t.Callable[[], None]) -> None:
+        self._cleanup_handlers.append(cleanup_handler)
+
+    def track_lock_file(self, lock_file_path: Path) -> None:
+        self._lock_files.add(lock_file_path)
+
+    def cleanup_resources(self) -> None:
+        for cleanup_handler in self._cleanup_handlers:
+            with suppress(Exception):
+                cleanup_handler()
+
+        self._cleanup_temporary_files()
+
+    def _cleanup_temporary_files(self) -> None:
+        if not hasattr(self, "_cleanup_config") or self._cleanup_config is None:
+            self._cleanup_debug_logs()
+            self._cleanup_coverage_files()
+            self._cleanup_pycache_directories()
+        elif self._cleanup_config.auto_cleanup:
+            self._cleanup_debug_logs(keep_recent=self._cleanup_config.keep_debug_logs)
+            self._cleanup_coverage_files(
+                keep_recent=self._cleanup_config.keep_coverage_files,
+            )
+            self._cleanup_pycache_directories()
+
+    def set_cleanup_config(self, cleanup_config: t.Any) -> None:
+        self._cleanup_config = cleanup_config
+
+    def _cleanup_debug_logs(self, keep_recent: int = 5) -> None:
+        with suppress(Exception):
+            from crackerjack.services.log_manager import get_log_manager
+
+            log_manager = get_log_manager()
+
+            log_manager.rotate_logs(
+                log_manager.debug_dir,
+                "debug-*.log",
+                max_files=keep_recent,
+                max_age_days=7,
+            )
+
+            legacy_pattern = "crackerjack-debug-*.log"
+            legacy_files = sorted(
+                self.pkg_path.glob(legacy_pattern),
+                key=lambda p: p.stat().st_mtime,
+            )
+
+            for old_file in legacy_files[:-keep_recent]:
+                with suppress(FileNotFoundError, PermissionError):
+                    old_file.unlink()
+
+    def _cleanup_coverage_files(self, keep_recent: int = 10) -> None:
+        with suppress(Exception):
+            # Clean up coverage files from cache directory
+            cache_dir = Path.home() / ".cache" / "crackerjack" / "coverage"
+            if cache_dir.exists():
+                pattern = ".coverage*"
+                coverage_files = sorted(
+                    cache_dir.glob(pattern),
+                    key=lambda p: p.stat().st_mtime,
+                )
+
+                for old_file in coverage_files[:-keep_recent]:
+                    with suppress(FileNotFoundError, PermissionError):
+                        old_file.unlink()
+
+            # Also clean up any legacy coverage files from project root
+            pattern = ".coverage.*"
+            coverage_files = sorted(
+                self.pkg_path.glob(pattern),
+                key=lambda p: p.stat().st_mtime,
+            )
+
+            for old_file in coverage_files:
+                with suppress(FileNotFoundError, PermissionError):
+                    old_file.unlink()
+
+    def _cleanup_pycache_directories(self) -> None:
+        """Remove __pycache__ directories from the package to keep repo clean."""
+        with suppress(Exception):
+            import shutil
+
+            # Clean __pycache__ directories in package
+            for pycache_dir in self.pkg_path.rglob("__pycache__"):
+                if pycache_dir.is_dir():
+                    with suppress(FileNotFoundError, PermissionError):
+                        shutil.rmtree(pycache_dir)
+
+    def _setup_logging(self) -> None:
+        logger = logging.getLogger("crackerjack")
+        if not logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setLevel(logging.WARNING)
+            logger.addHandler(handler)
+            logger.setLevel(logging.WARNING)
+
+    def _setup_websocket_progress_file(self) -> None:
+        import tempfile
+
+        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
+        self.progress_file = self.progress_dir / f"job-{self.web_job_id}.json"
+
+        if self.progress_file.exists():
+            self._update_websocket_progress("running", "Crackerjack process started")
+
+    def _update_websocket_progress(self, status: str, message: str) -> None:
+        if not hasattr(self, "progress_file") or not self.progress_file:
+            return
+
+        try:
+            progress_data = {}
+            if self.progress_file.exists():
+                progress_data = json.loads(self.progress_file.read_text())
+
+            progress_data.update(
+                {
+                    "status": status,
+                    "message": message,
+                    "updated_at": time.time(),
+                    "current_stage": message,
+                },
+            )
+
+            self.progress_file.write_text(json.dumps(progress_data, indent=2))
+
+        except Exception as e:
+            self.console.print(
+                f"[dim yellow]Warning: Could not update progress file: {e}[/dim yellow]",
+            )
+
+    def update_stage(self, stage: str, status: str) -> None:
+        if self.web_job_id:
+            self._update_websocket_progress(status, f"{stage}: {status}")