crackerjack 0.38.0__tar.gz → 0.38.2__tar.gz

{crackerjack-0.38.0 → crackerjack-0.38.2}/CHANGELOG.md

@@ -5,6 +5,22 @@ 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).
 
+## [0.38.2] - 2025-09-18
+
+### Documentation
+
+- config: Update 4 files
+
+## [0.38.1] - 2025-09-18
+
+### Changed
+
+- Crackerjack (quality: 76/100) - 2025-09-18 03:07:52
+
+### Fixed
+
+- crackerjack: Update 8 files
+
 ## [0.38.0] - 2025-09-17
 
 ### Changed

{crackerjack-0.38.0 → crackerjack-0.38.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.38.0
+Version: 0.38.2
 Summary: Crackerjack Python project management tool
 Project-URL: documentation, https://github.com/lesleslie/crackerjack
 Project-URL: homepage, https://github.com/lesleslie/crackerjack
@@ -67,13 +67,14 @@ Description-Content-Type: text/markdown
 
 # Crackerjack: Advanced AI-Driven Python Development Platform
 
+[![Code style: crackerjack](https://img.shields.io/badge/code%20style-crackerjack-000042)](https://github.com/lesleslie/crackerjack)
 [![Python: 3.13+](https://img.shields.io/badge/python-3.13%2B-green)](https://www.python.org/downloads/)
 [![pytest](https://img.shields.io/badge/pytest-coverage%20ratchet-blue)](https://pytest.org)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![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-37.1%25-red)
+![Coverage](https://img.shields.io/badge/coverage-17.7%25-red)
 
 ## 🎯 Purpose
 

{crackerjack-0.38.0 → crackerjack-0.38.2}/README.md

@@ -1,12 +1,13 @@
 # Crackerjack: Advanced AI-Driven Python Development Platform
 
+[![Code style: crackerjack](https://img.shields.io/badge/code%20style-crackerjack-000042)](https://github.com/lesleslie/crackerjack)
 [![Python: 3.13+](https://img.shields.io/badge/python-3.13%2B-green)](https://www.python.org/downloads/)
 [![pytest](https://img.shields.io/badge/pytest-coverage%20ratchet-blue)](https://pytest.org)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![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-37.1%25-red)
+![Coverage](https://img.shields.io/badge/coverage-17.7%25-red)
 
 ## 🎯 Purpose
 

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/__main__.py

@@ -11,6 +11,7 @@ from crackerjack.services.git import GitService
 
 from .cli import (
     CLI_OPTIONS,
+    BumpOption,
     create_options,
     handle_interactive_mode,
     handle_standard_mode,
@@ -1219,9 +1220,9 @@ def main(
     update_precommit: bool = CLI_OPTIONS["update_precommit"],
     verbose: bool = CLI_OPTIONS["verbose"],
     debug: bool = CLI_OPTIONS["debug"],
-    publish: str | None = CLI_OPTIONS["publish"],
+    publish: BumpOption | None = CLI_OPTIONS["publish"],
     all: str | None = CLI_OPTIONS["all"],
-    bump: str | None = CLI_OPTIONS["bump"],
+    bump: BumpOption | None = CLI_OPTIONS["bump"],
     strip_code: bool = CLI_OPTIONS["strip_code"],
     run_tests: bool = CLI_OPTIONS["run_tests"],
     benchmark: bool = CLI_OPTIONS["benchmark"],
@@ -1466,6 +1467,10 @@ def _process_all_commands(local_vars: t.Any, console: t.Any, options: t.Any) ->
     ):
         return False
 
+    # Handle coverage status command
+    if not _handle_coverage_status(local_vars["coverage_status"], console, options):
+        return False
+
     # Handle documentation and analysis commands
     return _handle_analysis_commands(local_vars, console, options)
 
@@ -1538,6 +1543,78 @@ def _handle_specialized_analytics(local_vars: t.Any, console: t.Any) -> bool:
     return _handle_enterprise_features(local_vars, console)
 
 
+def _handle_coverage_status(
+    coverage_status: bool, console: t.Any, options: t.Any
+) -> bool:
+    """Handle coverage status display command."""
+    if not coverage_status:
+        return True
+
+    try:
+        from pathlib import Path
+
+        from crackerjack.managers.test_manager import TestManager
+
+        # Use current working directory as package path
+        pkg_path = Path.cwd()
+
+        # Create test manager directly
+        test_manager = TestManager(console, pkg_path)
+
+        console.print("[cyan]📊[/cyan] Coverage Status Report")
+        console.print("=" * 50)
+
+        # 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]")
+
+        # 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}")
+
+        # 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
+
+        console.print()
+        return False  # Exit after showing status
+
+    except Exception as e:
+        console.print(f"[red]❌[/red] Failed to get coverage status: {e}")
+        import traceback
+
+        console.print(f"[dim]{traceback.format_exc()}[/dim]")
+        return False
+
+
 def _handle_enterprise_features(local_vars: t.Any, console: t.Any) -> bool:
     """Handle enterprise features."""
     # Handle enterprise optimizer

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/cli/options.py

@@ -934,8 +934,8 @@ def create_options(
     update_precommit: bool,
     verbose: bool,
     debug: bool,
-    publish: str | None,
-    bump: str | None,
+    publish: BumpOption | None,
+    bump: BumpOption | None,
     benchmark: bool,
     test_workers: int,
     test_timeout: int,

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/core/workflow_orchestrator.py

@@ -66,6 +66,7 @@ class WorkflowPipeline:
         self._cache = get_performance_cache()
 
         # Initialize quality intelligence for advanced decision making
+        self._quality_intelligence: QualityIntelligenceService | None
         try:
             quality_baseline = EnhancedQualityBaselineService()
             self._quality_intelligence = QualityIntelligenceService(quality_baseline)
@@ -74,6 +75,7 @@ class WorkflowPipeline:
             self._quality_intelligence = None
 
         # Initialize performance benchmarking for workflow analysis
+        self._performance_benchmarks: PerformanceBenchmarkService | None
         try:
             self._performance_benchmarks = PerformanceBenchmarkService(
                 console, pkg_path
@@ -241,7 +243,7 @@ class WorkflowPipeline:
             self.logger.warning(f"Failed to auto-start Zuban LSP server: {e}")
 
     def _get_zuban_lsp_config(
-        self, options: OptionsProtocol, config: any
+        self, options: OptionsProtocol, config: t.Any
     ) -> tuple[int, str]:
         """Get Zuban LSP configuration values."""
         if config:
@@ -384,7 +386,7 @@ class WorkflowPipeline:
 
     def _gather_performance_metrics(
         self, workflow_id: str, duration: float, success: bool
-    ) -> dict:
+    ) -> dict[str, t.Any]:
         """Gather performance metrics from workflow execution."""
         return {
             "workflow_id": workflow_id,
@@ -622,7 +624,7 @@ class WorkflowPipeline:
             comprehensive_passed,
         ) = await self._run_main_quality_phases_async(options, workflow_id)
 
-        return await self._handle_workflow_completion(
+        return await self._handle_ai_workflow_completion(
             options, iteration, testing_passed, comprehensive_passed, workflow_id
         )
 
@@ -650,7 +652,7 @@ class WorkflowPipeline:
         self._mark_code_cleaning_complete()
         return True
 
-    async def _handle_workflow_completion(
+    async def _handle_ai_workflow_completion(
         self,
         options: OptionsProtocol,
         iteration: int,
@@ -1871,7 +1873,66 @@ class WorkflowPipeline:
     ) -> bool:
         with phase_monitor(workflow_id, "testing") as monitor:
             monitor.record_sequential_op()
-            return self._run_testing_phase(options)
+            test_result = self._run_testing_phase(options)
+
+            # Execute coverage improvement if boost_coverage is enabled and tests passed
+            if test_result and getattr(options, "boost_coverage", False):
+                await self._execute_coverage_improvement(options)
+
+            return test_result
+
+    async def _execute_coverage_improvement(self, options: OptionsProtocol) -> None:
+        """Execute coverage improvement when boost_coverage is enabled."""
+        try:
+            from crackerjack.orchestration.coverage_improvement import (
+                create_coverage_improvement_orchestrator,
+            )
+
+            coverage_orchestrator = await create_coverage_improvement_orchestrator(
+                self.pkg_path, console=self.console
+            )
+
+            should_improve = await coverage_orchestrator.should_improve_coverage()
+            if not should_improve:
+                self.console.print(
+                    "[dim]📈 Coverage at 100% - no improvement needed[/dim]"
+                )
+                return
+
+            # Create agent context for coverage improvement
+            from crackerjack.agents.base import AgentContext
+            from crackerjack.services.filesystem_enhanced import FileSystemService
+
+            filesystem_service = FileSystemService(self.pkg_path)
+            agent_context = AgentContext(
+                pkg_path=self.pkg_path,
+                filesystem=filesystem_service,
+                console=self.console,
+            )
+
+            result = await coverage_orchestrator.execute_coverage_improvement(
+                agent_context
+            )
+
+            if result["status"] == "completed":
+                self.console.print(
+                    f"[green]📈[/green] Coverage improvement: {len(result.get('fixes_applied', []))} "
+                    f"tests created in {len(result.get('files_modified', []))} files"
+                )
+            elif result["status"] == "skipped":
+                self.console.print(
+                    f"[dim]📈 Coverage improvement skipped: {result.get('reason', 'Unknown')}[/dim]"
+                )
+            else:
+                self.console.print(
+                    "[yellow]⚠️[/yellow] Coverage improvement completed with issues"
+                )
+
+        except Exception as e:
+            self.console.print(
+                f"[yellow]⚠️[/yellow] Coverage improvement failed: {str(e)}"
+            )
+            self.logger.warning(f"Coverage improvement error: {e}")
 
     async def _execute_standard_hooks_workflow_monitored(
         self, options: OptionsProtocol, workflow_id: str

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/managers/publish_manager.py

@@ -156,7 +156,7 @@ class PublishManagerImpl:
             self.console.print(f"[red]❌[/ red] Version bump failed: {e}")
             raise
 
-    def _prompt_for_version_type(self, recommendation=None) -> str:
+    def _prompt_for_version_type(self, recommendation: t.Any = None) -> str:
         try:
             from rich.prompt import Prompt
 
@@ -178,7 +178,7 @@ class PublishManagerImpl:
             )
             return "patch"
 
-    def _get_version_recommendation(self):
+    def _get_version_recommendation(self) -> t.Any:
         """Get AI-powered version bump recommendation based on git history."""
         try:
             import asyncio
@@ -217,7 +217,7 @@ class PublishManagerImpl:
             self.console.print(f"[yellow]⚠️[/yellow] Version analysis failed: {e}")
             return None
 
-    def _display_version_analysis(self, recommendation):
+    def _display_version_analysis(self, recommendation: t.Any) -> None:
         """Display version analysis in a compact format."""
         if not recommendation:
             return

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/managers/test_manager.py

@@ -132,21 +132,72 @@ class TestManager:
         try:
             status = self.coverage_ratchet.get_status_report()
 
-            if status.get("status") == "not_initialized":
+            # 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
+
+            # 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",
+                }
+
+            # 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",
                 }
 
+            # 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
+            )
+
             return {
                 "status": "active",
-                "coverage_percent": status.get("current_coverage", 0.0),
+                "coverage_percent": final_coverage,
                 "target_coverage": status.get("target_coverage", 100.0),
                 "next_milestone": status.get("next_milestone"),
                 "progress_percent": status.get("progress_percent", 0.0),
                 "last_updated": status.get("last_updated"),
                 "milestones_achieved": status.get("milestones_achieved", []),
+                "source": "coverage.json" if direct_coverage is not None else "ratchet",
             }
         except Exception as e:
             return {
@@ -235,25 +286,83 @@ class TestManager:
             current_coverage = None
             coverage_json_path = self.pkg_path / "coverage.json"
 
+            # Primary: Try to extract from coverage.json
             if coverage_json_path.exists():
-                with coverage_json_path.open() as f:
-                    data = json.load(f)
-                    current_coverage = data.get("totals", {}).get("percent_covered")
+                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}"
+                    )
 
-            # Fallback to ratchet result if coverage.json not available
+            # 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]"
+                    )
 
-            # Final fallback to coverage service
+            # Tertiary: Try coverage service, but only accept non-zero values
             if current_coverage is None:
                 coverage_info = self.get_coverage()
-                current_coverage = coverage_info.get("coverage_percent")
+                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:
+                    self.console.print(
+                        "[yellow]⚠️[/yellow] Skipping 0.0% fallback when coverage.json exists"
+                    )
 
-            if current_coverage is not None:
+            # 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):
                     self._coverage_badge_service.update_readme_coverage_badge(
                         current_coverage
                     )
+                    self.console.print(
+                        f"[green]✅[/green] Badge updated to {current_coverage:.2f}%"
+                    )
+                else:
+                    self.console.print(
+                        f"[dim]📊 Badge unchanged (current: {current_coverage:.2f}%)[/dim]"
+                    )
+            else:
+                self.console.print(
+                    "[yellow]⚠️[/yellow] No valid coverage data found for badge update"
+                )
+
         except Exception as e:
             # Don't fail the test process if badge update fails
             self.console.print(f"[yellow]⚠️[/yellow] Badge update failed: {e}")

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/mcp/file_monitor.py

@@ -5,10 +5,20 @@ import typing as t
 from collections.abc import Callable
 from pathlib import Path
 
+# Type aliases for watchdog types
+FileSystemEvent: t.Any
+FileSystemEventHandler: t.Any
+Observer: t.Any
+WATCHDOG_AVAILABLE: bool
+
 try:
-    from watchdog.events import FileSystemEvent, FileSystemEventHandler
-    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEvent as WatchdogFileSystemEvent
+    from watchdog.events import FileSystemEventHandler as WatchdogFileSystemEventHandler
+    from watchdog.observers import Observer as WatchdogObserver
 
+    FileSystemEvent = WatchdogFileSystemEvent
+    FileSystemEventHandler = WatchdogFileSystemEventHandler
+    Observer = WatchdogObserver
     WATCHDOG_AVAILABLE = True
 except ImportError:
     # Type stubs for when watchdog is not available

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/mcp/rate_limiter.py

@@ -35,14 +35,18 @@ class RateLimiter:
         self.requests_per_hour = requests_per_hour
 
         self.minute_windows: dict[str, deque[float]] = defaultdict(
-            lambda: deque(maxlen=requests_per_minute),  # type: ignore[misc]
+            lambda: deque[float](maxlen=requests_per_minute),  # type: ignore[arg-type,misc]
         )
         self.hour_windows: dict[str, deque[float]] = defaultdict(
-            lambda: deque(maxlen=requests_per_hour),  # type: ignore[misc]
+            lambda: deque[float](maxlen=requests_per_hour),  # type: ignore[arg-type,misc]
         )
 
-        self.global_minute_window: deque[float] = deque(maxlen=requests_per_minute * 10)
-        self.global_hour_window: deque[float] = deque(maxlen=requests_per_hour * 10)
+        self.global_minute_window: deque[float] = deque[float](
+            maxlen=requests_per_minute * 10
+        )
+        self.global_hour_window: deque[float] = deque[float](
+            maxlen=requests_per_hour * 10
+        )
 
         self._lock = asyncio.Lock()
 
@@ -126,7 +130,7 @@ class RateLimiter:
         self._remove_expired_entries(self.global_minute_window, minute_cutoff)
         self._remove_expired_entries(self.global_hour_window, hour_cutoff)
 
-    def _remove_expired_entries(self, window: deque, cutoff: float) -> None:
+    def _remove_expired_entries(self, window: deque[float], cutoff: float) -> None:
         while window and window[0] < cutoff:
             window.popleft()
 

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/mcp/service_watchdog.py

@@ -3,6 +3,7 @@ import socket
 import subprocess
 import sys
 import time
+from contextlib import suppress
 from typing import Any
 
 import aiohttp
@@ -34,7 +35,7 @@ class ServiceConfig:
         self.max_restarts = max_restarts
         self.restart_window = restart_window
 
-        self.process: subprocess.Popen[bytes] | None = None
+        self.process: subprocess.Popen[str] | None = None
         self.restart_count = 0
         self.restart_timestamps: list[float] = []
         self.last_health_check = 0.0
@@ -125,7 +126,7 @@ class ServiceWatchdog:
         return False
 
     async def _launch_service_process(self, service: ServiceConfig) -> bool:
-        service.process = subprocess.Popen(
+        service.process = subprocess.Popen[str](
             service.command,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
@@ -137,6 +138,8 @@ class ServiceWatchdog:
         return await self._check_process_startup_success(service)
 
     async def _check_process_startup_success(self, service: ServiceConfig) -> bool:
+        if service.process is None:
+            return False
         exit_code = service.process.poll()
         if exit_code is not None:
             return await self._handle_process_died(service, exit_code)
@@ -147,6 +150,8 @@ class ServiceWatchdog:
         service: ServiceConfig,
         exit_code: int,
     ) -> bool:
+        if service.process is None:
+            return False
         stdout, stderr = service.process.communicate()
         error_msg = f"Process died (exit: {exit_code})"
         if stderr and stderr.strip():
@@ -441,8 +446,6 @@ class ServiceWatchdog:
         message: str,
     ) -> None:
         if self.event_queue:
-            from contextlib import suppress
-
             with suppress(Exception):
                 event = {
                     "type": event_type,

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/mcp/tools/intelligence_tools.py

@@ -147,7 +147,7 @@ async def get_smart_agent_recommendation(
             context=task_context,
         )
 
-        response = {
+        response: dict[str, t.Any] = {
             "task_description": task_description,
             "context_type": context_type,
         }

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/mcp/tools/proactive_tools.py

@@ -119,7 +119,7 @@ def _create_validation_results(file_path: str) -> dict[str, t.Any]:
 
 
 def _create_pattern_suggestions(problem_context: str) -> dict[str, t.Any]:
-    pattern_suggestions = {
+    pattern_suggestions: dict[str, t.Any] = {
         "context": problem_context,
         "recommended_patterns": [],
         "implementation_guidance": [],

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/orchestration/execution_strategies.py

@@ -262,10 +262,10 @@ class OrchestrationPlanner:
             hook_plans=hook_plans,
             test_plan=test_plan,
             ai_plan=ai_plan,
-            estimated_total_duration=sum(
-                int(plan["estimated_duration"]) for plan in hook_plans
+            estimated_total_duration=float(
+                sum(int(float(str(plan["estimated_duration"]))) for plan in hook_plans)
             )
-            + test_plan["estimated_duration"],
+            + float(test_plan["estimated_duration"]),
         )
 
     def _estimate_strategy_duration(self, strategy: HookStrategy) -> float:

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/plugins/hooks.py

@@ -131,6 +131,7 @@ class CustomHookPlugin(HookPluginBase):
         try:
             if hook_def.command is None:
                 return HookResult(
+                    id=f"hook_{hook_def.name}",
                     name=hook_def.name,
                     status="failed",
                     issues_found=["Hook command is None"],

{crackerjack-0.38.0 → crackerjack-0.38.2}/crackerjack/plugins/loader.py

@@ -132,7 +132,7 @@ class PluginLoader:
 
     def _try_factory_function(
         self,
-        factory: t.Callable,
+        factory: t.Callable[..., t.Any],
         name: str,
     ) -> PluginBase | None:
         try: