crackerjack 0.38.10__py3-none-any.whl → 0.38.11__py3-none-any.whl

crackerjack/__main__.py

@@ -1543,6 +1543,47 @@ def _handle_specialized_analytics(local_vars: t.Any, console: t.Any) -> bool:
     return _handle_enterprise_features(local_vars, console)
 
 
+def _display_coverage_info(console: t.Any, coverage_info: dict[str, t.Any]) -> None:
+    """Display basic coverage information."""
+    coverage_percent = coverage_info.get("coverage_percent", 0.0)
+    coverage_source = coverage_info.get("source", "unknown")
+
+    if coverage_percent > 0:
+        console.print(
+            f"[green]Current Coverage:[/green] {coverage_percent:.2f}% (from {coverage_source})"
+        )
+    else:
+        console.print("[yellow]Current Coverage:[/yellow] No coverage data available")
+
+    # Show status message if available
+    status_message = coverage_info.get("message")
+    if status_message:
+        console.print(f"[dim]{status_message}[/dim]")
+
+
+def _display_coverage_report(console: t.Any, test_manager: t.Any) -> None:
+    """Display detailed coverage report if available."""
+    coverage_report = test_manager.get_coverage_report()
+    if coverage_report:
+        console.print(f"[cyan]Details:[/cyan] {coverage_report}")
+
+
+def _display_ratchet_status(console: t.Any, test_manager: t.Any) -> None:
+    """Display coverage ratchet status if available."""
+    from contextlib import suppress
+
+    with suppress(Exception):
+        ratchet_status = test_manager.get_coverage_ratchet_status()
+        if ratchet_status:
+            next_milestone = ratchet_status.get("next_milestone")
+            if next_milestone:
+                console.print(f"[cyan]Next Milestone:[/cyan] {next_milestone:.0f}%")
+
+            milestones = ratchet_status.get("milestones_achieved", [])
+            if milestones:
+                console.print(f"[green]Milestones Achieved:[/green] {len(milestones)}")
+
+
 def _handle_coverage_status(
     coverage_status: bool, console: t.Any, options: t.Any
 ) -> bool:
@@ -1566,43 +1607,13 @@ def _handle_coverage_status(
 
         # Get coverage information
         coverage_info = test_manager.get_coverage()
-        coverage_percent = coverage_info.get("coverage_percent", 0.0)
-        coverage_source = coverage_info.get("source", "unknown")
-
-        if coverage_percent > 0:
-            console.print(
-                f"[green]Current Coverage:[/green] {coverage_percent:.2f}% (from {coverage_source})"
-            )
-        else:
-            console.print(
-                "[yellow]Current Coverage:[/yellow] No coverage data available"
-            )
-
-        # Show status message if available
-        status_message = coverage_info.get("message")
-        if status_message:
-            console.print(f"[dim]{status_message}[/dim]")
+        _display_coverage_info(console, coverage_info)
 
         # Try to get more detailed coverage report
-        coverage_report = test_manager.get_coverage_report()
-        if coverage_report:
-            console.print(f"[cyan]Details:[/cyan] {coverage_report}")
+        _display_coverage_report(console, test_manager)
 
         # Show coverage ratchet status if available
-        try:
-            ratchet_status = test_manager.get_coverage_ratchet_status()
-            if ratchet_status:
-                next_milestone = ratchet_status.get("next_milestone")
-                if next_milestone:
-                    console.print(f"[cyan]Next Milestone:[/cyan] {next_milestone:.0f}%")
-
-                milestones = ratchet_status.get("milestones_achieved", [])
-                if milestones:
-                    console.print(
-                        f"[green]Milestones Achieved:[/green] {len(milestones)}"
-                    )
-        except Exception:
-            pass  # Ignore ratchet status errors
+        _display_ratchet_status(console, test_manager)
 
         console.print()
         return False  # Exit after showing status

crackerjack/interactive.py

@@ -34,6 +34,26 @@ class InteractiveWorkflowOptions:
     interactive: bool = True
     dry_run: bool = False
 
+    def __init__(
+        self,
+        clean: bool = False,
+        test: bool = False,
+        publish: str | None = None,
+        bump: str | None = None,
+        commit: bool = False,
+        create_pr: bool = False,
+        interactive: bool = True,
+        dry_run: bool = False,
+    ) -> None:
+        self.clean = clean
+        self.test = test
+        self.publish = publish
+        self.bump = bump
+        self.commit = commit
+        self.create_pr = create_pr
+        self.interactive = interactive
+        self.dry_run = dry_run
+
     @classmethod
     def from_args(cls, args: t.Any) -> "InteractiveWorkflowOptions":
         return cls(

crackerjack/managers/test_command_builder.py

@@ -38,23 +38,25 @@ class TestCommandBuilder:
         # Method 1: Try to read from pyproject.toml
         pyproject_path = self.pkg_path / "pyproject.toml"
         if pyproject_path.exists():
-            try:
+            from contextlib import suppress
+
+            with suppress(Exception):
                 import tomllib
+
                 with pyproject_path.open("rb") as f:
                     data = tomllib.load(f)
                     project_name = data.get("project", {}).get("name")
                     if project_name:
                         # Convert project name to package name (hyphens to underscores)
                         return project_name.replace("-", "_")
-            except Exception:
-                pass  # Fall back to directory detection
+            # Fall back to directory detection
 
         # Method 2: Look for Python packages in the project root
         for item in self.pkg_path.iterdir():
             if (
                 item.is_dir()
                 and not item.name.startswith(".")
-                and not item.name in ("tests", "docs", "build", "dist", "__pycache__")
+                and item.name not in ("tests", "docs", "build", "dist", "__pycache__")
                 and (item / "__init__.py").exists()
             ):
                 return item.name

crackerjack/managers/test_manager.py

@@ -128,66 +128,91 @@ class TestManager:
         except Exception:
             return None
 
+    def _get_coverage_from_file(self) -> float | None:
+        """Extract coverage from coverage.json file."""
+        import json
+
+        coverage_json_path = self.pkg_path / "coverage.json"
+        if not coverage_json_path.exists():
+            return None
+
+        try:
+            with coverage_json_path.open() as f:
+                coverage_data = json.load(f)
+
+            # Extract coverage percentage from totals
+            totals = coverage_data.get("totals", {})
+            percent_covered = totals.get("percent_covered", None)
+
+            if percent_covered is not None:
+                return float(percent_covered)
+
+            # Alternative extraction methods for different coverage formats
+            if "percent_covered" in coverage_data:
+                return float(coverage_data["percent_covered"])
+
+            # Check for coverage in files section
+            files = coverage_data.get("files", {})
+            if files:
+                total_lines = 0
+                covered_lines = 0
+                for file_data in files.values():
+                    summary = file_data.get("summary", {})
+                    total_lines += summary.get("num_statements", 0)
+                    covered_lines += summary.get("covered_lines", 0)
+
+                if total_lines > 0:
+                    return (covered_lines / total_lines) * 100
+
+            return None
+
+        except (json.JSONDecodeError, ValueError, KeyError, TypeError):
+            return None
+
+    def _handle_no_ratchet_status(
+        self, direct_coverage: float | None
+    ) -> dict[str, t.Any]:
+        """Handle case when ratchet is not initialized."""
+        if direct_coverage is not None:
+            return {
+                "status": "coverage_available",
+                "coverage_percent": direct_coverage,
+                "message": "Coverage data available from coverage.json",
+                "source": "coverage.json",
+            }
+
+        return {
+            "status": "not_initialized",
+            "coverage_percent": 0.0,
+            "message": "Coverage ratchet not initialized",
+        }
+
+    def _get_final_coverage(
+        self, ratchet_coverage: float, direct_coverage: float | None
+    ) -> float:
+        """Determine final coverage value."""
+        return direct_coverage if direct_coverage is not None else ratchet_coverage
+
     def get_coverage(self) -> dict[str, t.Any]:
         try:
             status = self.coverage_ratchet.get_status_report()
 
             # Check if we have actual coverage data from coverage.json even if ratchet is not initialized
-            coverage_json_path = self.pkg_path / "coverage.json"
-            direct_coverage = None
-
-            if coverage_json_path.exists():
-                try:
-                    import json
-
-                    with coverage_json_path.open() as f:
-                        data = json.load(f)
-                        # Check for totals field first (newer format)
-                        direct_coverage = data.get("totals", {}).get("percent_covered")
-
-                        # If no totals, calculate from files data (standard pytest-cov format)
-                        if direct_coverage is None and "files" in data:
-                            total_statements = 0
-                            total_covered = 0
-
-                            for file_data in data["files"].values():
-                                summary = file_data.get("summary", {})
-                                statements = summary.get("num_statements", 0)
-                                covered = summary.get("covered_lines", 0)
-                                total_statements += statements
-                                total_covered += covered
-
-                            if total_statements > 0:
-                                direct_coverage = (
-                                    total_covered / total_statements
-                                ) * 100
-                except (json.JSONDecodeError, KeyError):
-                    pass  # Fall back to ratchet data
+            direct_coverage = self._get_coverage_from_file()
 
             # If ratchet is not initialized but we have direct coverage data, use it
             if (
                 not status or status.get("status") == "not_initialized"
             ) and direct_coverage is not None:
-                return {
-                    "status": "coverage_available",
-                    "coverage_percent": direct_coverage,
-                    "message": "Coverage data available from coverage.json",
-                    "source": "coverage.json",
-                }
+                return self._handle_no_ratchet_status(direct_coverage)
 
             # If ratchet is not initialized and no direct coverage, return not initialized
             if not status or status.get("status") == "not_initialized":
-                return {
-                    "status": "not_initialized",
-                    "coverage_percent": 0.0,
-                    "message": "Coverage ratchet not initialized",
-                }
+                return self._handle_no_ratchet_status(None)
 
             # Use ratchet data, but prefer direct coverage if available and different
             ratchet_coverage = status.get("current_coverage", 0.0)
-            final_coverage = (
-                direct_coverage if direct_coverage is not None else ratchet_coverage
-            )
+            final_coverage = self._get_final_coverage(ratchet_coverage, direct_coverage)
 
             return {
                 "status": "active",
@@ -277,74 +302,65 @@ class TestManager:
 
         return self._handle_ratchet_result(ratchet_result)
 
-    def _update_coverage_badge(self, ratchet_result: dict[str, t.Any]) -> None:
-        """Update coverage badge in README.md if coverage changed."""
-        try:
-            # Get current coverage directly from coverage.json to ensure freshest data
-            import json
-
-            current_coverage = None
-            coverage_json_path = self.pkg_path / "coverage.json"
-
-            # Primary: Try to extract from coverage.json
-            if coverage_json_path.exists():
-                try:
-                    with coverage_json_path.open() as f:
-                        data = json.load(f)
-                        # Check for totals field first (newer format)
-                        current_coverage = data.get("totals", {}).get("percent_covered")
-
-                        # If no totals, calculate from files data (standard pytest-cov format)
-                        if current_coverage is None and "files" in data:
-                            total_statements = 0
-                            total_covered = 0
-
-                            for file_data in data["files"].values():
-                                summary = file_data.get("summary", {})
-                                statements = summary.get("num_statements", 0)
-                                covered = summary.get("covered_lines", 0)
-                                total_statements += statements
-                                total_covered += covered
-
-                            if total_statements > 0:
-                                current_coverage = (
-                                    total_covered / total_statements
-                                ) * 100
-
-                        if current_coverage is not None:
-                            self.console.print(
-                                f"[dim]📊 Coverage extracted from coverage.json: {current_coverage:.2f}%[/dim]"
-                            )
-                except (json.JSONDecodeError, KeyError) as e:
-                    self.console.print(
-                        f"[yellow]⚠️[/yellow] Failed to parse coverage.json: {e}"
-                    )
+    def _attempt_coverage_extraction(self) -> float | None:
+        """Attempt to extract coverage from various sources."""
+        # Primary: Try to extract from coverage.json
+        current_coverage = self._get_coverage_from_file()
+        if current_coverage is not None:
+            return current_coverage
 
-            # Secondary: Try ratchet result if coverage.json failed
-            if current_coverage is None:
-                current_coverage = ratchet_result.get("current_coverage")
-                if current_coverage is not None:
-                    self.console.print(
-                        f"[dim]📊 Coverage from ratchet result: {current_coverage:.2f}%[/dim]"
-                    )
+        return None
 
-            # Tertiary: Try coverage service, but only accept non-zero values
-            if current_coverage is None:
-                coverage_info = self.get_coverage()
-                fallback_coverage = coverage_info.get("coverage_percent")
-                # Only use fallback if it's meaningful (>0) or if no coverage.json exists
-                if fallback_coverage and (
-                    fallback_coverage > 0 or not coverage_json_path.exists()
-                ):
-                    current_coverage = fallback_coverage
-                    self.console.print(
-                        f"[dim]📊 Coverage from service fallback: {current_coverage:.2f}%[/dim]"
-                    )
-                else:
+    def _handle_coverage_extraction_result(
+        self, current_coverage: float | None
+    ) -> float | None:
+        """Handle the result of coverage extraction attempts."""
+        if current_coverage is not None:
+            self.console.print(
+                f"[dim]📊 Coverage extracted from coverage.json: {current_coverage:.2f}%[/dim]"
+            )
+        return current_coverage
+
+    def _get_fallback_coverage(
+        self, ratchet_result: dict[str, t.Any], current_coverage: float | None
+    ) -> float | None:
+        """Get coverage from fallback sources."""
+        # Secondary: Try ratchet result if coverage.json failed
+        if current_coverage is None:
+            current_coverage = self._get_coverage_from_ratchet(ratchet_result)
+            if current_coverage is not None:
+                self.console.print(
+                    f"[dim]📊 Coverage from ratchet result: {current_coverage:.2f}%[/dim]"
+                )
+
+        # Tertiary: Try coverage service, but only accept non-zero values
+        if current_coverage is None:
+            current_coverage = self._get_coverage_from_service()
+            if current_coverage is not None:
+                self.console.print(
+                    f"[dim]📊 Coverage from service fallback: {current_coverage:.2f}%[/dim]"
+                )
+            else:
+                coverage_json_path = self.pkg_path / "coverage.json"
+                if coverage_json_path.exists():
                     self.console.print(
                         "[yellow]⚠️[/yellow] Skipping 0.0% fallback when coverage.json exists"
                     )
 
+        return current_coverage
+
+    def _update_coverage_badge(self, ratchet_result: dict[str, t.Any]) -> None:
+        """Update coverage badge in README.md if coverage changed."""
+        try:
+            # Get current coverage directly from coverage.json to ensure freshest data
+            current_coverage = self._attempt_coverage_extraction()
+            current_coverage = self._handle_coverage_extraction_result(current_coverage)
+
+            # Get fallback coverage if needed
+            current_coverage = self._get_fallback_coverage(
+                ratchet_result, current_coverage
+            )
+
             # Only update badge if we have valid coverage data
             if current_coverage is not None and current_coverage >= 0:
                 if self._coverage_badge_service.should_update_badge(current_coverage):

crackerjack/monitoring/ai_agent_watchdog.py

@@ -21,7 +21,7 @@ class AgentPerformanceMetrics:
     failed_fixes: int = 0
     average_confidence: float = 0.0
     average_execution_time: float = 0.0
-    issue_types_handled: dict[IssueType, int] = field(default_factory=dict[str, t.Any])
+    issue_types_handled: dict[IssueType, int] = field(default_factory=dict)
     recent_failures: list[str] = field(default_factory=list)
     last_successful_fix: datetime | None = None
     regression_patterns: list[str] = field(default_factory=list)

crackerjack/orchestration/advanced_orchestrator.py

@@ -1,6 +1,5 @@
 import time
 import typing as t
-from contextlib import suppress
 from pathlib import Path
 
 from rich.console import Console, Group
@@ -101,94 +100,47 @@ class CorrelationTracker:
         }
 
 
-class MinimalProgressStreamer(ProgressStreamer):
+class ProgressStreamer:
+    """Base class for streaming progress updates during orchestration."""
+
     def __init__(
         self,
         config: OrchestrationConfig | None = None,
         session: SessionCoordinator | None = None,
     ) -> None:
-        # Minimal implementation doesn't use config or session
-        pass
+        self.config = config
+        self.session = session
 
     def update_stage(self, stage: str, substage: str = "") -> None:
+        """Update current stage."""
         pass
 
     def update_hook_progress(self, progress: HookProgress) -> None:
+        """Update hook progress."""
         pass
 
     def _stream_update(self, data: dict[str, t.Any]) -> None:
+        """Stream update data."""
         pass
 
 
-class ProgressStreamer:
+class MinimalProgressStreamer(ProgressStreamer):
     def __init__(
         self,
-        config: OrchestrationConfig,
-        session: SessionCoordinator,
+        config: OrchestrationConfig | None = None,
+        session: SessionCoordinator | None = None,
     ) -> None:
-        self.config = config
-        self.session = session
-        self.current_stage = "initialization"
-        self.current_substage = ""
-        self.hook_progress: dict[str, HookProgress] = {}
+        # Minimal implementation doesn't use config or session
+        pass
 
     def update_stage(self, stage: str, substage: str = "") -> None:
-        self.current_stage = stage
-        self.current_substage = substage
-        self._stream_update(
-            {
-                "type": "stage_update",
-                "stage": stage,
-                "substage": substage,
-                "timestamp": time.time(),
-            },
-        )
+        pass
 
     def update_hook_progress(self, progress: HookProgress) -> None:
-        self.hook_progress[progress.hook_name] = progress
-        self._stream_update(
-            {
-                "type": "hook_progress",
-                "hook_name": progress.hook_name,
-                "progress": progress.to_dict(),
-                "timestamp": time.time(),
-            },
-        )
-
-    def _stream_update(self, update_data: dict[str, t.Any]) -> None:
-        self.session.update_stage(
-            self.current_stage,
-            f"{self.current_substage}: {update_data.get('hook_name', 'processing')}",
-        )
-
-        if hasattr(self.session, "web_job_id") and self.session.web_job_id:
-            self._update_websocket_progress(update_data)
-
-    def _update_websocket_progress(self, update_data: dict[str, t.Any]) -> None:
-        with suppress(Exception):
-            if hasattr(self.session, "progress_file") and self.session.progress_file:
-                import json
-
-                progress_data: dict[str, t.Any] = {}
-                if self.session.progress_file.exists():
-                    with self.session.progress_file.open() as f:
-                        progress_data = json.load(f)
-
-                progress_data.update(
-                    {
-                        "current_stage": self.current_stage,
-                        "current_substage": self.current_substage,
-                        "hook_progress": {
-                            name: prog.to_dict()
-                            for name, prog in self.hook_progress.items()
-                        },
-                        "last_update": update_data,
-                        "updated_at": time.time(),
-                    },
-                )
+        pass
 
-                with self.session.progress_file.open("w") as f:
-                    json.dump(progress_data, f, indent=2)
+    def _stream_update(self, data: dict[str, t.Any]) -> None:
+        pass
 
 
 class AdvancedWorkflowOrchestrator:

crackerjack/services/git.py

@@ -1,4 +1,4 @@
-import subprocess
+import subprocess  # nosec B404
 import typing as t
 from pathlib import Path
 
@@ -156,7 +156,7 @@ class GitService:
 
     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"
+            "[yellow]🔄[/yellow] Pre-commit hooks modified files - attempting to re-stage and retry commit"
         )
 
         add_result = self._run_git_command(GIT_COMMANDS["add_updated"])

{crackerjack-0.38.10.dist-info → crackerjack-0.38.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.38.10
+Version: 0.38.11
 Summary: Crackerjack Python project management tool
 Project-URL: documentation, https://github.com/lesleslie/crackerjack
 Project-URL: homepage, https://github.com/lesleslie/crackerjack
@@ -48,7 +48,6 @@ Requires-Dist: refurb>=2.1
 Requires-Dist: rich>=14.1
 Requires-Dist: ruff>=0.12.9
 Requires-Dist: scipy>=1.14.0
-Requires-Dist: session-mgmt-mcp>=0.3.11
 Requires-Dist: skylos>=2.1.2
 Requires-Dist: structlog>=24.4
 Requires-Dist: textual>=0.89
@@ -75,7 +74,7 @@ Description-Content-Type: text/markdown
 [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
 [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
 [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-![Coverage](https://img.shields.io/badge/coverage-17.7%25-red)
+![Coverage](https://img.shields.io/badge/coverage-18.1%25-red)
 
 ## 🎯 Purpose
 

{crackerjack-0.38.10.dist-info → crackerjack-0.38.11.dist-info}/RECORD

@@ -1,11 +1,11 @@
 crackerjack/CLAUDE.md,sha256=FnF1XgcaCB59HEZxglEl4qEBTMyHQcqKoL0YjnAq24s,41230
 crackerjack/__init__.py,sha256=DajG9zHB8qBdgdiKMumrrssUbKeMXmtIQ3oOaSTb46Y,1426
-crackerjack/__main__.py,sha256=cAM0ezqddeO5oC3QMr8zpUor-RN0lIG-Zja_WeatDiY,55176
+crackerjack/__main__.py,sha256=hOekfMkVBYQuw294OHa8fhpuQa-E8knJh3x4KY1WxG8,55552
 crackerjack/api.py,sha256=PyCRaZHvKWdu62_2O4t_HcEfKNBdqyrfPdonS_PNn4c,21495
 crackerjack/code_cleaner.py,sha256=M1zVaq31uW0nOkPneKR8kfR3892gyyVx0VhFgRaxsj4,44338
 crackerjack/dynamic_config.py,sha256=4c8Fts9vyH8Tdon_47OFVT1iTBINSzSgB0WoeSvpzII,22418
 crackerjack/errors.py,sha256=yYbZ92kn_y6acEWgQvEPvozAYs2HT65uLwAXrtXxGsE,10049
-crackerjack/interactive.py,sha256=CYu53ySL2I1YCWRRRHmVEYQq3RQ0xDCXFTuPUAw6DTc,21399
+crackerjack/interactive.py,sha256=t5FbxWeOErSl5kod4V8Gu5yF5yuWoZlwqlOdquOQ-vo,21943
 crackerjack/adapters/__init__.py,sha256=k-8ajMDL9DS9hV2FYOu694nmNQg3HkudJRuNcXmx8N4,451
 crackerjack/adapters/lsp_client.py,sha256=4kQ3T5JiWC7uc6kOjZuPdtUboseKSDjZpuKQpV74onc,10963
 crackerjack/adapters/rust_tool_adapter.py,sha256=ui_qMt_WIwInRvRCeT7MnIdp8eln7Fvp4hakXQiVnjg,5999
@@ -86,9 +86,9 @@ crackerjack/managers/__init__.py,sha256=PFWccXx4hDQA76T02idAViOLVD-aPeVpgjdfSkh_
 crackerjack/managers/async_hook_manager.py,sha256=c0HFR98sFwfk0uZ3NmAe_6OVZpBrq9I570V8A2DoIxw,5129
 crackerjack/managers/hook_manager.py,sha256=_FT0ngwPwujqg0KZGpLz-pP07mwDmptJ5pVkiy5yS8k,7820
 crackerjack/managers/publish_manager.py,sha256=E0jqHuscfn89pI2Ely0R6xyi3EGTvYFQeFTWyRmdjBM,22067
-crackerjack/managers/test_command_builder.py,sha256=O1hH4sJ4MZNr509j962Q6zzZzayKkZZSZr9AE5jUH4k,4895
+crackerjack/managers/test_command_builder.py,sha256=9LWnXFOQ1nJfzbOTJNO6btIgDVc6uDHK7qiD2ol0FGI,4922
 crackerjack/managers/test_executor.py,sha256=2837Ti4OaNsmLxnmELjbQ18hmfL0-Z2EW-W2UeFSDcE,13871
-crackerjack/managers/test_manager.py,sha256=ClApfL9e3K1qe3vVcVbC8Y84CMJO55mwPegXiaTw9g8,18638
+crackerjack/managers/test_manager.py,sha256=fiJXSIHFi_knKsOI6f8-TOTJa1jgG1TzZL6T2KYlTdM,18382
 crackerjack/managers/test_manager_backup.py,sha256=CR8D7WZ68ZrTADFqYJtVDUWnlznJXJNriPIdsp6ZB1E,37932
 crackerjack/managers/test_progress.py,sha256=B1013ygUk2nAo37whDXNA7n-FYdsEO4qj17fuDm_fdg,3058
 crackerjack/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -135,12 +135,12 @@ crackerjack/models/protocols.py,sha256=ZtyatubJxnmnnTKzXWCbl8CvREPt2pywSco5KYBJI
 crackerjack/models/resource_protocols.py,sha256=oZiq0NEG2kWV0XQ871GIYRx_0v_oQulvEjTbidTbueM,7297
 crackerjack/models/task.py,sha256=Du5vwXj-P_aSIZsFt1Ek4jCTkXz_6DXfnflUxgXkecY,4542
 crackerjack/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-crackerjack/monitoring/ai_agent_watchdog.py,sha256=bc29uV9uAGFjQvL36vOtmpsYAhZCwqsOs8i1I6cmegE,15150
+crackerjack/monitoring/ai_agent_watchdog.py,sha256=_Usni6d8A-1CKAx2d5LUMXYldMiQB5cdZPd-NrCe2p8,15138
 crackerjack/monitoring/metrics_collector.py,sha256=PTeOTXk07HWvPwTDK5j-Ef7LPrrNiwouz4_jw0LcP7M,15920
 crackerjack/monitoring/regression_prevention.py,sha256=hV7jwKBXjS9gBVbqHTGEr9BxtKLHkXEg6zPDgTmOeWc,20986
 crackerjack/monitoring/websocket_server.py,sha256=tmCYh5Qp58iicS_txj5OTdmt3I85M5bAGONeyrv0-EQ,24965
 crackerjack/orchestration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-crackerjack/orchestration/advanced_orchestrator.py,sha256=RFvyJuUrL2-Vrii4XPX1NNtF-tcBWbbnyokqSe6sxmQ,34000
+crackerjack/orchestration/advanced_orchestrator.py,sha256=05AZhCkPIiKSVVpIx7gb2_wVvGAKHv7gStu146ivcmY,32066
 crackerjack/orchestration/coverage_improvement.py,sha256=XUTUcgub0nP3vvQ8Ud5SmCYKgulEe8SAY65jbcFQzdw,6869
 crackerjack/orchestration/execution_strategies.py,sha256=M3hplgaCULMwE9TiqP9rWvivnrqdSR6DJTzY_rvueww,12482
 crackerjack/orchestration/test_progress_streamer.py,sha256=Yu6uHuhoCvX6SZP0QNG3Yt8Q4s2tufEHr40o16QU98c,22541
@@ -175,7 +175,7 @@ crackerjack/services/enterprise_optimizer.py,sha256=q6srIGxe18N9zH-MNhZ9R34sWnr_
 crackerjack/services/error_pattern_analyzer.py,sha256=YKFQi_nXx5dq-Wvi6AngKEaA-Bv5ggTQ2B2ML0AtF0c,24415
 crackerjack/services/file_hasher.py,sha256=eReytwwK-_-B8JBnpwytDC52cKKgg4qpaxaZKcQjD-0,5211
 crackerjack/services/filesystem.py,sha256=nmL3mYqylS_BSQpwFbC7EMHoA44K5qUxa9CPg1QFZvc,17480
-crackerjack/services/git.py,sha256=g0D9K7PFGWiv_-CbPXEhGtxJVJccEsshYNEmGstjXss,12716
+crackerjack/services/git.py,sha256=E4z-hdA0UR-y5FY2A8d3fugt5Q41lonLAIt_op2Zde0,12727
 crackerjack/services/health_metrics.py,sha256=nDuKEC2a5csOhMpy6zXJkls1Y4Vfrr62-4cFcWCr8ow,21536
 crackerjack/services/heatmap_generator.py,sha256=zz5V-zXPfoCGNXoj7iuyOeFuDRRUhFpxuENUnd0X75g,26200
 crackerjack/services/initialization.py,sha256=_ZjGpIG5eGHzrVXCxlhlouhY-E-4OITEln1GDTswZ6s,26049
@@ -225,8 +225,8 @@ crackerjack/tools/validate_input_validator_patterns.py,sha256=NN7smYlXWrHLQXTb-8
 crackerjack/tools/validate_regex_patterns.py,sha256=J7GG9EP1fASpRIsG8qRPeiCSkdCwmk0sdo29GgoJ6w8,5863
 crackerjack/ui/__init__.py,sha256=eMb1OeTU-dSLICAACn0YdYB4Amdr8wHckjKfn0wOIZE,37
 crackerjack/ui/server_panels.py,sha256=F5IH6SNN06BaZQMsFx_D-OA286aojmaFPJ5kvvSRv_c,4232
-crackerjack-0.38.10.dist-info/METADATA,sha256=lF3_aqP8gfMzPi8Bak4nikLXGyMlZHPi1mhoAbbWm4k,38123
-crackerjack-0.38.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-crackerjack-0.38.10.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
-crackerjack-0.38.10.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
-crackerjack-0.38.10.dist-info/RECORD,,
+crackerjack-0.38.11.dist-info/METADATA,sha256=zlNpnIwM-e0waeO6GFqQpCowVWE4inrrE05ZSCdDk64,38083
+crackerjack-0.38.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+crackerjack-0.38.11.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
+crackerjack-0.38.11.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
+crackerjack-0.38.11.dist-info/RECORD,,