crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/orchestration/coverage_improvement.py

@@ -20,7 +20,7 @@ class CoverageImprovementOrchestrator:
     ) -> bool:
         try:
             if current_coverage is None:
-                coverage_status = self.coverage_service.get_status_report()
+                coverage_status = self.coverage_service.get_ratchet_data()
                 current_coverage = coverage_status.get("current_coverage", 0.0)
 
             if current_coverage is not None and current_coverage < 100.0:
@@ -42,7 +42,7 @@ class CoverageImprovementOrchestrator:
     ) -> Issue:
         if coverage_gap is None:
             try:
-                coverage_status = self.coverage_service.get_status_report()
+                coverage_status = self.coverage_service.get_ratchet_data()
                 current_coverage = coverage_status.get("current_coverage", 0.0)
                 coverage_gap = 100.0 - current_coverage
             except Exception:
@@ -150,7 +150,7 @@ class CoverageImprovementOrchestrator:
         from contextlib import suppress
 
         with suppress(Exception):
-            coverage_status = self.coverage_service.get_status_report()
+            coverage_status = self.coverage_service.get_ratchet_data()
             current_coverage = coverage_status.get("current_coverage", 0.0)
 
             if current_coverage < 25.0:

crackerjack/orchestration/execution_strategies.py

@@ -95,8 +95,8 @@ class ExecutionContext:
         self.changed_files = changed_files or []
         self.iteration_count = iteration_count
 
-        self.total_python_files = len(list(pkg_path.rglob(" * .py")))
-        self.total_test_files = len(list(pkg_path.glob("tests / test_ * .py")))
+        self.total_python_files = len(list[t.Any](pkg_path.rglob(" * .py")))
+        self.total_test_files = len(list[t.Any](pkg_path.glob("tests / test_ * .py")))
         self.has_complex_setup = self._detect_complex_setup()
         self.estimated_hook_duration = self._estimate_hook_duration()
 
@@ -105,8 +105,8 @@ class ExecutionContext:
             (self.pkg_path / "pyproject.toml").exists(),
             (self.pkg_path / "setup.py").exists(),
             (self.pkg_path / "requirements.txt").exists(),
-            len(list(self.pkg_path.rglob(" * .py"))) > 50,
-            len(list(self.pkg_path.glob("tests / test_ * .py"))) > 20,
+            len(list[t.Any](self.pkg_path.rglob(" * .py"))) > 50,
+            len(list[t.Any](self.pkg_path.glob("tests / test_ * .py"))) > 20,
         ]
         return sum(complex_indicators) >= 3
 
@@ -117,6 +117,26 @@ class ExecutionContext:
 
         return base_time + file_factor + test_factor
 
+    @property
+    def ai_agent_mode(self) -> bool:
+        """Check if AI agent mode is enabled."""
+        return getattr(self.options, "ai_agent", False)
+
+    @property
+    def ai_debug_mode(self) -> bool:
+        """Check if AI debug mode is enabled."""
+        return getattr(self.options, "ai_debug", False)
+
+    @property
+    def interactive(self) -> bool:
+        """Check if interactive mode is enabled."""
+        return getattr(self.options, "interactive", False)
+
+    @property
+    def working_directory(self) -> Path:
+        """Get the working directory path."""
+        return self.pkg_path
+
 
 class StrategySelector:
     def __init__(self, console: Console) -> None:
@@ -169,7 +189,7 @@ class StrategySelector:
         strategy: HookStrategy,
         context: ExecutionContext,
     ) -> HookStrategy:
-        priority_hooks = set(context.previous_failures)
+        priority_hooks = set[t.Any](context.previous_failures)
 
         if context.changed_files:
             for file_path in context.changed_files:
@@ -243,7 +263,7 @@ class OrchestrationPlanner:
             test_plan=test_plan,
             ai_plan=ai_plan,
             estimated_total_duration=sum(
-                plan["estimated_duration"] for plan in hook_plans
+                int(plan["estimated_duration"]) for plan in hook_plans
             )
             + test_plan["estimated_duration"],
         )

crackerjack/orchestration/test_progress_streamer.py

@@ -109,7 +109,6 @@ class PytestOutputParser:
         self.test_traceback_buffer: list[str] = []
         self.in_traceback = False
 
-        # Cache compiled patterns for optimal performance during test parsing
         self._test_start_pattern = CompiledPatternCache.get_compiled_pattern(
             SAFE_PATTERNS["pytest_test_start"].pattern
         )
@@ -144,7 +143,7 @@ class PytestOutputParser:
             self._process_current_test_line(line, suite_info)
 
         return {
-            "tests": list(tests.values()),
+            "tests": list[t.Any](tests.values()),
             "suite_progress": suite_info,
             "test_count": len(tests),
         }
@@ -155,6 +154,7 @@ class PytestOutputParser:
         suite_info: TestSuiteProgress,
     ) -> None:
         if match := self._test_collection_pattern.search(line):
+            assert match is not None  # Type checker: match cannot be None here
             suite_info.total_tests = int(match.group(1))
 
     def _process_test_result_line(
@@ -164,6 +164,7 @@ class PytestOutputParser:
         suite_info: TestSuiteProgress,
     ) -> None:
         if match := self._detailed_test_pattern.match(line):
+            assert match is not None  # Type checker: match cannot be None here
             file_path, test_name, status = match.groups()
             test_id = f"{file_path}:: {test_name}"
 
@@ -212,6 +213,7 @@ class PytestOutputParser:
 
     def _process_coverage_line(self, line: str, suite_info: TestSuiteProgress) -> None:
         if match := self._coverage_pattern.search(line):
+            assert match is not None  # Type checker: match cannot be None here
             suite_info.coverage_percentage = float(match.group(1))
 
     def _process_current_test_line(
@@ -225,9 +227,9 @@ class PytestOutputParser:
             suite_info.current_test = line.split()[0] if line.split() else None
 
     def parse_test_failure_details(self, output_lines: list[str]) -> dict[str, str]:
-        failures = {}
-        current_test = None
-        current_traceback = []
+        failures: dict[str, str] = {}
+        current_test: str | None = None
+        current_traceback: list[str] = []
         in_failure_section = False
 
         for line in output_lines:
@@ -531,6 +533,7 @@ class TestProgressStreamer:
                 suite_progress.current_test = parts[0]
 
         if match := self.parser._test_collection_pattern.search(line):
+            assert match is not None  # Type checker: match cannot be None here
             suite_progress.total_tests = int(match.group(1))
 
         if "PASSED" in line:

crackerjack/plugins/base.py

@@ -24,7 +24,7 @@ class PluginMetadata:
     requires_python: str = "> = 3.11"
     dependencies: list[str] = field(default_factory=list)
     entry_point: str = ""
-    config_schema: dict[str, t.Any] = field(default_factory=dict)
+    config_schema: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
 
     def to_dict(self) -> dict[str, t.Any]:
         return {
@@ -148,7 +148,7 @@ class PluginRegistry:
         if plugin_type:
             plugins = self.get_by_type(plugin_type)
         else:
-            plugins = list(self._plugins.values())
+            plugins = list[t.Any](self._plugins.values())
 
         return [p for p in plugins if p.enabled]
 

crackerjack/plugins/hooks.py

@@ -129,6 +129,13 @@ class CustomHookPlugin(HookPluginBase):
         start_time = time.time()
 
         try:
+            if hook_def.command is None:
+                return HookResult(
+                    name=hook_def.name,
+                    status="failed",
+                    message="Hook command is None",
+                    duration=0.0,
+                )
             cmd = hook_def.command.copy()
             if hook_def.requires_files and files:
                 cmd.extend(str(f) for f in files)

crackerjack/plugins/managers.py

@@ -7,7 +7,7 @@ from rich.console import Console
 from crackerjack.models.protocols import OptionsProtocol
 
 from .base import PluginRegistry, PluginType, get_plugin_registry
-from .hooks import HookPluginRegistry, get_hook_plugin_registry
+from .hooks import HookPluginBase, HookPluginRegistry, get_hook_plugin_registry
 from .loader import PluginDiscovery, PluginLoader
 
 
@@ -59,9 +59,10 @@ class PluginManager:
 
             hook_plugins = self.registry.get_enabled(PluginType.HOOK)
             for plugin in hook_plugins:
-                if hasattr(plugin, "initialize"):
-                    plugin.initialize(self.console, self.project_path)
-                self.hook_registry.register_hook_plugin(plugin)
+                if isinstance(plugin, HookPluginBase):
+                    if hasattr(plugin, "initialize"):
+                        plugin.initialize(self.console, self.project_path)
+                    self.hook_registry.register_hook_plugin(plugin)
 
             self._initialized = True
             return True
@@ -97,7 +98,7 @@ class PluginManager:
         if plugin_type:
             plugins = self.registry.get_by_type(plugin_type)
         else:
-            plugins = list(self.registry.list_all().values())
+            plugins = list[t.Any](self.registry.list_all().values())
 
         plugin_info = []
         for plugin in plugins:
@@ -120,7 +121,7 @@ class PluginManager:
         stats["hook_plugins"] = {
             "active_plugins": len(hook_plugins),
             "total_custom_hooks": len(custom_hooks),
-            "hook_names": list(custom_hooks.keys()),
+            "hook_names": list[t.Any](custom_hooks.keys()),
         }
 
         return stats
@@ -144,7 +145,9 @@ class PluginManager:
             if success:
                 self.console.print(f"[green]✅[/ green] Enabled plugin: {plugin_name}")
 
-                if plugin.plugin_type == PluginType.HOOK:
+                if plugin.plugin_type == PluginType.HOOK and isinstance(
+                    plugin, HookPluginBase
+                ):
                     self.hook_registry.register_hook_plugin(plugin)
 
                 return True
@@ -250,7 +253,7 @@ class PluginManager:
 
     def get_available_custom_hooks(self) -> list[str]:
         custom_hooks = self.hook_registry.get_all_custom_hooks()
-        return list(custom_hooks.keys())
+        return list[t.Any](custom_hooks.keys())
 
     def execute_custom_hook(
         self,

crackerjack/security/__init__.py

@@ -1 +0,0 @@
-"""Security utilities for Crackerjack."""

crackerjack/security/audit.py

@@ -1,16 +1,11 @@
-"""Security audit utilities for secure SDLC practices."""
-
 import typing as t
 from dataclasses import dataclass
-from enum import Enum
 
 from crackerjack.config.hooks import SecurityLevel
 
 
 @dataclass
 class SecurityCheckResult:
-    """Result of a security check."""
-    
     hook_name: str
     security_level: SecurityLevel
     passed: bool
@@ -18,74 +13,55 @@ class SecurityCheckResult:
     details: dict[str, t.Any] | None = None
 
 
-@dataclass  
+@dataclass
 class SecurityAuditReport:
-    """Comprehensive security audit report for publishing decisions."""
-    
     critical_failures: list[SecurityCheckResult]
-    high_failures: list[SecurityCheckResult] 
+    high_failures: list[SecurityCheckResult]
     medium_failures: list[SecurityCheckResult]
     low_failures: list[SecurityCheckResult]
-    
+
     allows_publishing: bool
     security_warnings: list[str]
     recommendations: list[str]
-    
+
     @property
     def has_critical_failures(self) -> bool:
-        """Check if there are any critical security failures."""
         return len(self.critical_failures) > 0
-    
+
     @property
     def total_failures(self) -> int:
-        """Get total number of failed checks."""
         return (
-            len(self.critical_failures) + 
-            len(self.high_failures) + 
-            len(self.medium_failures) + 
-            len(self.low_failures)
+            len(self.critical_failures)
+            + len(self.high_failures)
+            + len(self.medium_failures)
+            + len(self.low_failures)
         )
 
 
 class SecurityAuditor:
-    """Security auditor for hook results following OWASP secure SDLC practices."""
-    
-    # Security-critical hooks that CANNOT be bypassed for publishing
     CRITICAL_HOOKS = {
-        'bandit': 'Security vulnerability detection (OWASP A09)',
-        'pyright': 'Type safety prevents runtime security holes (OWASP A04)', 
-        'gitleaks': 'Secret/credential detection (OWASP A07)',
+        "bandit": "Security vulnerability detection (OWASP A09)",
+        "pyright": "Type safety prevents runtime security holes (OWASP A04)",
+        "gitleaks": "Secret/credential detection (OWASP A07)",
     }
-    
-    # High-importance security hooks that can be bypassed with warnings
+
     HIGH_SECURITY_HOOKS = {
-        'validate-regex-patterns': 'Regex vulnerability detection',
-        'creosote': 'Dependency vulnerability analysis',
-        'check-added-large-files': 'Large file security analysis',
-        'uv-lock': 'Dependency lock security',
+        "validate-regex-patterns": "Regex vulnerability detection",
+        "creosote": "Dependency vulnerability analysis",
+        "check-added-large-files": "Large file security analysis",
+        "uv-lock": "Dependency lock security",
     }
-    
+
     def audit_hook_results(
-        self, 
-        fast_results: list[t.Any], 
-        comprehensive_results: list[t.Any]
+        self, fast_results: list[t.Any], comprehensive_results: list[t.Any]
     ) -> SecurityAuditReport:
-        """Audit hook results and generate security report.
-        
-        Args:
-            fast_results: Results from fast hooks
-            comprehensive_results: Results from comprehensive hooks
-            
-        Returns:
-            SecurityAuditReport with security analysis
-        """
         all_results = fast_results + comprehensive_results
-        
+
         critical_failures = []
-        high_failures = []  
+        high_failures = []
         medium_failures = []
         low_failures = []
-        
+
         for result in all_results:
             check_result = self._analyze_hook_result(result)
             if not check_result.passed:
@@ -97,18 +73,17 @@ class SecurityAuditor:
                     medium_failures.append(check_result)
                 else:
                     low_failures.append(check_result)
-        
-        # Publishing is allowed only if no critical failures exist
+
         allows_publishing = len(critical_failures) == 0
-        
+
         security_warnings = self._generate_security_warnings(
             critical_failures, high_failures, medium_failures
         )
-        
+
         recommendations = self._generate_security_recommendations(
             critical_failures, high_failures, medium_failures
         )
-        
+
         return SecurityAuditReport(
             critical_failures=critical_failures,
             high_failures=high_failures,
@@ -118,95 +93,105 @@ class SecurityAuditor:
             security_warnings=security_warnings,
             recommendations=recommendations,
         )
-    
+
     def _analyze_hook_result(self, result: t.Any) -> SecurityCheckResult:
-        """Analyze a single hook result for security implications."""
-        hook_name = getattr(result, 'name', 'unknown')
-        is_failed = getattr(result, 'status', 'unknown') in ('failed', 'error', 'timeout')
-        error_message = getattr(result, 'output', None) or getattr(result, 'error', None)
-        
-        # Determine security level
+        hook_name = getattr(result, "name", "unknown")
+        is_failed = getattr(result, "status", "unknown") in (
+            "failed",
+            "error",
+            "timeout",
+        )
+        error_message = getattr(result, "output", None) or getattr(
+            result, "error", None
+        )
+
         security_level = self._get_hook_security_level(hook_name)
-        
+
         return SecurityCheckResult(
             hook_name=hook_name,
             security_level=security_level,
             passed=not is_failed,
             error_message=error_message,
-            details={'status': getattr(result, 'status', 'unknown')},
+            details={"status": getattr(result, "status", "unknown")},
         )
-    
+
     def _get_hook_security_level(self, hook_name: str) -> SecurityLevel:
-        """Get security level for a hook name."""
         hook_name_lower = hook_name.lower()
-        
-        if hook_name_lower in [name.lower() for name in self.CRITICAL_HOOKS]:
+
+        if hook_name_lower in (name.lower() for name in self.CRITICAL_HOOKS):
             return SecurityLevel.CRITICAL
-        elif hook_name_lower in [name.lower() for name in self.HIGH_SECURITY_HOOKS]:
+        elif hook_name_lower in (name.lower() for name in self.HIGH_SECURITY_HOOKS):
             return SecurityLevel.HIGH
-        elif hook_name_lower in ['ruff-check', 'vulture', 'refurb', 'complexipy']:
+        elif hook_name_lower in ("ruff-check", "vulture", "refurb", "complexipy"):
             return SecurityLevel.MEDIUM
-        else:
-            return SecurityLevel.LOW
-    
+        return SecurityLevel.LOW
+
     def _generate_security_warnings(
-        self, 
+        self,
         critical: list[SecurityCheckResult],
-        high: list[SecurityCheckResult], 
-        medium: list[SecurityCheckResult]
+        high: list[SecurityCheckResult],
+        medium: list[SecurityCheckResult],
     ) -> list[str]:
-        """Generate security warnings based on failed checks."""
         warnings = []
-        
+
         if critical:
             warnings.append(
                 f"🔒 CRITICAL: {len(critical)} security-critical checks failed - publishing BLOCKED"
             )
             for failure in critical:
-                reason = self.CRITICAL_HOOKS.get(failure.hook_name.lower(), "Security-critical check")
-                warnings.append(f"   • {failure.hook_name}: {reason}")
-        
+                reason = self.CRITICAL_HOOKS.get(
+                    failure.hook_name.lower(), "Security-critical check"
+                )
+                warnings.append(f" • {failure.hook_name}: {reason}")
+
         if high:
             warnings.append(
                 f"⚠️ HIGH: {len(high)} high-security checks failed - review recommended"
             )
-        
+
         if medium:
-            warnings.append(
-                f"ℹ️ MEDIUM: {len(medium)} standard quality checks failed"
-            )
-        
+            warnings.append(f"ℹ️ MEDIUM: {len(medium)} standard quality checks failed")
+
         return warnings
-    
+
     def _generate_security_recommendations(
         self,
         critical: list[SecurityCheckResult],
         high: list[SecurityCheckResult],
-        medium: list[SecurityCheckResult]
+        medium: list[SecurityCheckResult],
     ) -> list[str]:
-        """Generate security recommendations based on OWASP best practices."""
         recommendations = []
-        
+
         if critical:
-            recommendations.append("🔧 Fix all CRITICAL security issues before publishing")
-            
-            # Specific recommendations based on failed checks
+            recommendations.append(
+                "🔧 Fix all CRITICAL security issues before publishing"
+            )
+
             critical_names = [f.hook_name.lower() for f in critical]
-            
-            if 'bandit' in critical_names:
-                recommendations.append("   • Review bandit security findings - may indicate vulnerabilities")
-            if 'pyright' in critical_names:
-                recommendations.append("   • Fix type errors - type safety prevents runtime security holes")
-            if 'gitleaks' in critical_names:
-                recommendations.append("   • Remove secrets/credentials from code - use environment variables")
-        
+
+            if "bandit" in critical_names:
+                recommendations.append(
+                    " • Review bandit security findings - may indicate vulnerabilities"
+                )
+            if "pyright" in critical_names:
+                recommendations.append(
+                    " • Fix type errors - type safety prevents runtime security holes"
+                )
+            if "gitleaks" in critical_names:
+                recommendations.append(
+                    " • Remove secrets/credentials from code - use environment variables"
+                )
+
         if high:
-            recommendations.append("🔍 Review HIGH-security findings before production deployment")
-        
-        if len(critical) == 0 and len(high) == 0:
+            recommendations.append(
+                "🔍 Review HIGH-security findings before production deployment"
+            )
+
+        if not critical and not high:
             recommendations.append("✅ Security posture is acceptable for publishing")
-        
-        # Add OWASP best practices reference
-        recommendations.append("📖 Follow OWASP Secure Coding Practices for comprehensive security")
-        
-        return recommendations
+
+        recommendations.append(
+            "📖 Follow OWASP Secure Coding Practices for comprehensive security"
+        )
+
+        return recommendations