crackerjack 0.33.12__tar.gz → 0.34.0__tar.gz

{crackerjack-0.33.12 → crackerjack-0.34.0}/CHANGELOG.md

@@ -5,6 +5,12 @@ 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.34.0] - 2025-09-15
+
+### Changed
+
+- Update config, deps, docs
+
 ## [0.33.12] - 2025-09-15
 
 ### Changed

{crackerjack-0.33.12 → crackerjack-0.34.0}/CLAUDE.md

@@ -62,6 +62,52 @@ python -m crackerjack --full-release patch  # Full release workflow
 
 **Usage**: `--ai-fix` enables batch fixing; confidence ≥0.7 uses specific agents
 
+## Advanced Services (Enabled by Default)
+
+Crackerjack now includes sophisticated intelligence services that enhance the development experience automatically:
+
+### 🧠 Smart Commit Messages (Default)
+
+- **AI-Powered Analysis**: Analyzes staged changes using conventional commit patterns
+- **Context-Aware**: Considers file types, change patterns, and scope for descriptive messages
+- **Automatic Detection**: Identifies breaking changes, features, fixes, and refactoring
+- **Fallback Option**: Use `--basic-commit` to disable smart messages when needed
+
+### 📈 Version Intelligence (Integrated)
+
+- **Semantic Analysis**: AI recommends version bumps (major/minor/patch) based on commits
+- **Breaking Change Detection**: Automatically identifies API-breaking changes
+- **Conventional Commits**: Analyzes feat/fix/breaking patterns with confidence scoring
+- **Interactive Mode**: Use `--bump interactive` to see AI recommendations during selection
+
+### 📝 Changelog Automation (Default)
+
+- **Git History Analysis**: Automatically generates changelog entries from commits
+- **Categorized Entries**: Groups changes by type (Added, Fixed, Changed, etc.)
+- **Version Integration**: Updates changelog during version bumps and publishing
+- **Markdown Generation**: Creates properly formatted CHANGELOG.md entries
+
+### 🎯 Quality Intelligence (Active)
+
+- **Anomaly Detection**: ML-based quality trend analysis and early warning system
+- **Pattern Recognition**: Identifies improvement/regression patterns in code quality
+- **Workflow Decisions**: Influences hook selection based on quality history
+- **Predictive Analytics**: Recommends comprehensive vs. fast quality checks intelligently
+
+### ⚡ Performance Benchmarks (Reporting)
+
+- **Real-time Metrics**: Tracks workflow execution time and resource usage
+- **Improvement Analysis**: Shows performance gains from optimizations and caching
+- **Memory Optimization**: Reports cache hit ratios and memory efficiency metrics
+- **Historical Trends**: Maintains performance baselines for comparison
+
+**Integration Benefits**:
+
+- All services work together seamlessly with graceful fallbacks
+- Zero configuration required - intelligent defaults work out of the box
+- Enhanced developer experience with minimal performance impact
+- Comprehensive quality assurance with intelligent automation
+
 ## High-Performance Rust Integration
 
 **Ultra-Fast Static Analysis** with seamless Python integration:

{crackerjack-0.33.12 → crackerjack-0.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.33.12
+Version: 0.34.0
 Summary: Crackerjack Python project management tool
 Project-URL: documentation, https://github.com/lesleslie/crackerjack
 Project-URL: homepage, https://github.com/lesleslie/crackerjack

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/cli/options.py

@@ -110,7 +110,7 @@ class Options(BaseModel):
     accept_version: bool = False
 
     # Intelligent features
-    smart_commit: bool = False
+    smart_commit: bool = True  # Default enabled for advanced services integration
 
     # Analytics and visualization features
     heatmap: bool = False
@@ -733,9 +733,9 @@ CLI_OPTIONS = {
         help="Automatically accept version bump recommendation without confirmation.",
     ),
     "smart_commit": typer.Option(
-        False,
-        "--smart-commit",
-        help="Generate intelligent commit messages based on code changes using AI analysis.",
+        True,  # Now enabled by default for advanced services integration
+        "--smart-commit/--basic-commit",
+        help="Generate intelligent commit messages using AI analysis (default: enabled). Use --basic-commit for simple messages.",
     ),
     "heatmap": typer.Option(
         False,

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/core/phase_coordinator.py

@@ -474,8 +474,12 @@ class PhaseCoordinator(ErrorHandlingMixin):
         changed_files: list[str],
         options: OptionsProtocol,
     ) -> str:
-        # Check if smart commit is enabled
-        if getattr(options, "smart_commit", False):
+        # Smart commit is now enabled by default for all commit operations
+        # Use basic commit messages only if explicitly disabled
+        use_smart_commit = getattr(options, "smart_commit", True)
+        disable_smart_commit = getattr(options, "basic_commit", False)
+
+        if use_smart_commit and not disable_smart_commit:
             try:
                 from crackerjack.services.intelligent_commit import (
                     CommitMessageGenerator,

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/core/workflow_orchestrator.py

@@ -19,11 +19,16 @@ from crackerjack.services.logging import (
     setup_structured_logging,
 )
 from crackerjack.services.memory_optimizer import get_memory_optimizer, memory_optimized
+from crackerjack.services.performance_benchmarks import PerformanceBenchmarkService
 from crackerjack.services.performance_cache import get_performance_cache
 from crackerjack.services.performance_monitor import (
     get_performance_monitor,
     phase_monitor,
 )
+from crackerjack.services.quality_baseline_enhanced import (
+    EnhancedQualityBaselineService,
+)
+from crackerjack.services.quality_intelligence import QualityIntelligenceService
 
 from .phase_coordinator import PhaseCoordinator
 from .session_coordinator import SessionCoordinator
@@ -60,6 +65,25 @@ class WorkflowPipeline:
         self._memory_optimizer = get_memory_optimizer()
         self._cache = get_performance_cache()
 
+        # Initialize quality intelligence for advanced decision making
+        try:
+            quality_baseline = EnhancedQualityBaselineService(console, pkg_path)
+            self._quality_intelligence = QualityIntelligenceService(
+                quality_baseline, console
+            )
+        except Exception:
+            # Fallback gracefully if quality intelligence is not available
+            self._quality_intelligence = None
+
+        # Initialize performance benchmarking for workflow analysis
+        try:
+            self._performance_benchmarks = PerformanceBenchmarkService(
+                console, pkg_path
+            )
+        except Exception:
+            # Fallback gracefully if benchmarking is not available
+            self._performance_benchmarks = None
+
     @property
     def debugger(self) -> AIAgentDebugger | NoOpDebugger:
         if self._debugger is None:
@@ -297,6 +321,9 @@ class WorkflowPipeline:
         duration = time.time() - start_time
         self._log_workflow_completion(success, duration)
         self._log_workflow_completion_debug(success, duration)
+        await self._generate_performance_benchmark_report(
+            workflow_id, duration, success
+        )
 
         return success
 
@@ -318,6 +345,50 @@ class WorkflowPipeline:
             duration=duration,
         )
 
+    async def _generate_performance_benchmark_report(
+        self, workflow_id: str, duration: float, success: bool
+    ) -> None:
+        """Generate and display performance benchmark report for workflow execution."""
+        if not self._performance_benchmarks:
+            return
+
+        try:
+            # Gather performance metrics from the workflow execution
+            {
+                "workflow_id": workflow_id,
+                "total_duration": duration,
+                "success": success,
+                "cache_metrics": self._cache.get_stats() if self._cache else {},
+                "memory_metrics": self._memory_optimizer.get_stats()
+                if hasattr(self._memory_optimizer, "get_stats")
+                else {},
+            }
+
+            # Generate benchmark comparison
+            benchmark_results = await self._performance_benchmarks.run_benchmark_suite()
+
+            # Display compact performance summary
+            if benchmark_results:
+                self.console.print("\n[cyan]📊 Performance Benchmark Summary[/cyan]")
+                self.console.print(f"Workflow Duration: [bold]{duration:.2f}s[/bold]")
+
+                # Show key performance improvements if available
+                for result in benchmark_results.results[:3]:  # Top 3 results
+                    if result.time_improvement_percentage > 0:
+                        self.console.print(
+                            f"[green]⚡[/green] {result.test_name}: {result.time_improvement_percentage:.1f}% faster"
+                        )
+
+                    if result.cache_hit_ratio > 0:
+                        self.console.print(
+                            f"[blue]🎯[/blue] Cache efficiency: {result.cache_hit_ratio:.0%}"
+                        )
+
+        except Exception as e:
+            self.console.print(
+                f"[dim]⚠️ Performance benchmark failed: {str(e)[:50]}...[/dim]"
+            )
+
         if self.debugger.enabled:
             self.debugger.print_debug_summary()
 
@@ -391,6 +462,13 @@ class WorkflowPipeline:
     async def _execute_quality_phase(
         self, options: OptionsProtocol, workflow_id: str
     ) -> bool:
+        # Use quality intelligence to make informed decisions about quality phase
+        if self._quality_intelligence:
+            quality_decision = await self._make_quality_intelligence_decision(options)
+            self.console.print(
+                f"[dim]🧠 Quality Intelligence: {quality_decision}[/dim]"
+            )
+
         if hasattr(options, "fast") and options.fast:
             return await self._run_fast_hooks_phase_monitored(options, workflow_id)
         if hasattr(options, "comp") and options.comp:
@@ -403,6 +481,48 @@ class WorkflowPipeline:
             options, workflow_id
         )
 
+    async def _make_quality_intelligence_decision(
+        self, options: OptionsProtocol
+    ) -> str:
+        """Use quality intelligence to make informed decisions about workflow execution."""
+        try:
+            if not self._quality_intelligence:
+                return "Quality intelligence not available"
+
+            # Analyze recent quality trends and anomalies
+            anomalies = await self._quality_intelligence.detect_anomalies()
+            patterns = await self._quality_intelligence.identify_patterns()
+
+            # Make intelligent recommendations based on current state
+            recommendations = []
+            if anomalies:
+                high_severity_anomalies = [
+                    a for a in anomalies if a.severity.name in ["CRITICAL", "HIGH"]
+                ]
+                if high_severity_anomalies:
+                    recommendations.append(
+                        "comprehensive analysis recommended due to quality anomalies"
+                    )
+                else:
+                    recommendations.append("standard quality checks sufficient")
+
+            if patterns:
+                improving_patterns = [
+                    p for p in patterns if p.trend_direction.name == "IMPROVING"
+                ]
+                if improving_patterns:
+                    recommendations.append("quality trending upward")
+                else:
+                    recommendations.append("quality monitoring active")
+
+            if not recommendations:
+                recommendations.append("baseline quality analysis active")
+
+            return "; ".join(recommendations)
+
+        except Exception as e:
+            return f"Quality intelligence analysis failed: {str(e)[:50]}..."
+
     async def _execute_test_workflow(
         self, options: OptionsProtocol, workflow_id: str
     ) -> bool:

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/dynamic_config.py

@@ -457,8 +457,55 @@ PRE_COMMIT_TEMPLATE = """repos:
 
 
 class DynamicConfigGenerator:
-    def __init__(self) -> None:
+    def __init__(self, package_directory: str | None = None) -> None:
         self.template = jinja2.Template(PRE_COMMIT_TEMPLATE)
+        self.package_directory = package_directory or self._detect_package_directory()
+
+    def _detect_package_directory(self) -> str:
+        """Detect the package directory name for the current project."""
+        import os
+        from pathlib import Path
+
+        # Check if we're in the crackerjack project itself
+        current_dir = Path(os.getcwd())
+        if (current_dir / "crackerjack").exists() and (
+            current_dir / "pyproject.toml"
+        ).exists():
+            # Check if this is actually the crackerjack project
+            try:
+                import tomllib
+
+                with (current_dir / "pyproject.toml").open("rb") as f:
+                    data = tomllib.load(f)
+                if data.get("project", {}).get("name") == "crackerjack":
+                    return "crackerjack"
+            except Exception:
+                pass
+
+        # Try to read package name from pyproject.toml
+        pyproject_path = current_dir / "pyproject.toml"
+        if pyproject_path.exists():
+            try:
+                import tomllib
+
+                with pyproject_path.open("rb") as f:
+                    data = tomllib.load(f)
+
+                if "project" in data and "name" in data["project"]:
+                    package_name = str(data["project"]["name"])
+                    # Check if package directory exists
+                    if (current_dir / package_name).exists():
+                        return package_name
+            except Exception:
+                pass
+
+        # Fallback to common patterns
+        for possible_name in ("src", current_dir.name):
+            if (current_dir / possible_name).exists():
+                return possible_name
+
+        # Default fallback
+        return "src"
 
     def _should_include_hook(
         self,
@@ -486,10 +533,40 @@ class DynamicConfigGenerator:
         for category_hooks in HOOKS_REGISTRY.values():
             for hook in category_hooks:
                 if self._should_include_hook(hook, config, enabled_experimental):
-                    filtered_hooks.append(hook)
+                    # Create a copy and update package-specific configurations
+                    updated_hook = self._update_hook_for_package(hook.copy())
+                    filtered_hooks.append(updated_hook)
 
         return filtered_hooks
 
+    def _update_hook_for_package(self, hook: HookMetadata) -> HookMetadata:
+        """Update hook configuration to use the detected package directory."""
+        # Update skylos hook
+        if hook["id"] == "skylos" and hook["args"]:
+            hook["args"] = [self.package_directory]
+
+        # Update zuban hook
+        elif hook["id"] == "zuban" and hook["args"]:
+            # Replace the hardcoded "./crackerjack" with the dynamic package directory
+            updated_args = []
+            for arg in hook["args"]:
+                if arg == "./crackerjack":
+                    updated_args.append(f"./{self.package_directory}")
+                else:
+                    updated_args.append(arg)
+            hook["args"] = updated_args
+
+        # Update other hooks that use hardcoded "crackerjack" patterns
+        elif hook["files"] and "crackerjack" in hook["files"]:
+            hook["files"] = hook["files"].replace("crackerjack", self.package_directory)
+
+        elif hook["exclude"] and "crackerjack" in hook["exclude"]:
+            hook["exclude"] = hook["exclude"].replace(
+                "crackerjack", self.package_directory
+            )
+
+        return hook
+
     def group_hooks_by_repo(
         self,
         hooks: list[HookMetadata],
@@ -580,8 +657,11 @@ class DynamicConfigGenerator:
 def generate_config_for_mode(
     mode: str,
     enabled_experimental: list[str] | None = None,
+    package_directory: str | None = None,
 ) -> Path:
-    return DynamicConfigGenerator().create_temp_config(mode, enabled_experimental)
+    return DynamicConfigGenerator(package_directory).create_temp_config(
+        mode, enabled_experimental
+    )
 
 
 def get_available_modes() -> list[str]:

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/managers/publish_manager.py

@@ -122,8 +122,18 @@ class PublishManagerImpl:
             raise ValueError(msg)
         self.console.print(f"[cyan]📦[/ cyan] Current version: {current_version}")
 
+        # Get intelligent version analysis and recommendation
+        recommendation = self._get_version_recommendation()
+        if recommendation and version_type not in ["interactive"]:
+            self._display_version_analysis(recommendation)
+            if version_type == "auto":
+                version_type = recommendation.bump_type.value
+                self.console.print(
+                    f"[green]🎯[/green] Using AI-recommended bump type: {version_type}"
+                )
+
         if version_type == "interactive":
-            version_type = self._prompt_for_version_type()
+            version_type = self._prompt_for_version_type(recommendation)
 
         try:
             new_version = self._calculate_next_version(current_version, version_type)
@@ -146,14 +156,21 @@ class PublishManagerImpl:
             self.console.print(f"[red]❌[/ red] Version bump failed: {e}")
             raise
 
-    def _prompt_for_version_type(self) -> str:
+    def _prompt_for_version_type(self, recommendation=None) -> str:
         try:
             from rich.prompt import Prompt
 
+            default_type = "patch"
+            if recommendation:
+                default_type = recommendation.bump_type.value
+                self.console.print(
+                    f"[dim]AI recommendation: {default_type} (confidence: {recommendation.confidence:.0%})[/dim]"
+                )
+
             return Prompt.ask(
                 "[cyan]📦[/ cyan] Select version bump type",
                 choices=["patch", "minor", "major"],
-                default="patch",
+                default=default_type,
             )
         except ImportError:
             self.console.print(
@@ -161,6 +178,73 @@ class PublishManagerImpl:
             )
             return "patch"
 
+    def _get_version_recommendation(self):
+        """Get AI-powered version bump recommendation based on git history."""
+        try:
+            import asyncio
+
+            from crackerjack.services.git import GitService
+            from crackerjack.services.version_analyzer import VersionAnalyzer
+
+            # Initialize services
+            git_service = GitService(self.console, self.pkg_path)
+            version_analyzer = VersionAnalyzer(self.console, git_service)
+
+            # Get recommendation asynchronously
+            try:
+                # Try to get existing event loop
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    # Create a new event loop in a thread if one is already running
+                    import concurrent.futures
+
+                    with concurrent.futures.ThreadPoolExecutor() as executor:
+                        future = executor.submit(
+                            asyncio.run, version_analyzer.recommend_version_bump()
+                        )
+                        recommendation = future.result(timeout=10)
+                else:
+                    recommendation = loop.run_until_complete(
+                        version_analyzer.recommend_version_bump()
+                    )
+            except RuntimeError:
+                # No event loop, create one
+                recommendation = asyncio.run(version_analyzer.recommend_version_bump())
+
+            return recommendation
+
+        except Exception as e:
+            self.console.print(f"[yellow]⚠️[/yellow] Version analysis failed: {e}")
+            return None
+
+    def _display_version_analysis(self, recommendation):
+        """Display version analysis in a compact format."""
+        if not recommendation:
+            return
+
+        self.console.print("\n[cyan]🎯 AI Version Analysis[/cyan]")
+        self.console.print(
+            f"Recommended: [bold green]{recommendation.recommended_version}[/bold green] "
+            f"({recommendation.bump_type.value.upper()}) - {recommendation.confidence:.0%} confidence"
+        )
+
+        if recommendation.reasoning:
+            self.console.print(f"[dim]→ {recommendation.reasoning[0]}[/dim]")
+
+        # Show key changes briefly
+        if recommendation.breaking_changes:
+            self.console.print(
+                f"[red]⚠️[/red] {len(recommendation.breaking_changes)} breaking changes detected"
+            )
+        elif recommendation.new_features:
+            self.console.print(
+                f"[green]✨[/green] {len(recommendation.new_features)} new features detected"
+            )
+        elif recommendation.bug_fixes:
+            self.console.print(
+                f"[blue]🔧[/blue] {len(recommendation.bug_fixes)} bug fixes detected"
+            )
+
     def validate_auth(self) -> bool:
         auth_methods = self._collect_auth_methods()
         return self._report_auth_status(auth_methods)

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/managers/test_manager_backup.py

@@ -71,7 +71,7 @@ class TestProgress:
             border_style="yellow",
             title_style="bold yellow",
             expand=True,
-            min_width=80,
+            min_width=74,
         )
 
         table.add_column("Type", style="cyan", ratio=1)
@@ -106,7 +106,7 @@ class TestProgress:
             border_style="cyan",
             title_style="bold cyan",
             expand=True,
-            min_width=80,
+            min_width=74,
         )
 
         table.add_column("Metric", style="cyan", ratio=1)

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/services/config.py

@@ -12,12 +12,20 @@ class ConfigurationService:
     def __init__(self, console: Console, pkg_path: Path) -> None:
         self.console = console
         self.pkg_path = pkg_path
-        self.config_generator = DynamicConfigGenerator()
+        # Extract package directory name from the pkg_path
+        package_directory = pkg_path.name if pkg_path != Path.cwd() else None
+        self.config_generator = DynamicConfigGenerator(package_directory)
 
     def update_precommit_config(self, options: OptionsProtocol) -> bool:
         try:
             mode = self._determine_config_mode(options)
-            config_temp_path = generate_config_for_mode(mode)
+            # Extract package directory name from the pkg_path
+            package_directory = (
+                self.pkg_path.name if self.pkg_path != Path.cwd() else None
+            )
+            config_temp_path = generate_config_for_mode(
+                mode, package_directory=package_directory
+            )
             if not config_temp_path:
                 self.console.print("[yellow]⚠️ No configuration generated[/ yellow]")
                 return False

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/services/performance_benchmarks.py

@@ -130,7 +130,7 @@ class PerformanceBenchmarker:
             obj = {
                 "data": f"heavy_data_{i}" * 100,
                 "metadata": {"created": time.time(), "index": i},
-                "payload": list[t.Any](range(100)),
+                "payload": list(range(100)),
             }
             heavy_objects.append(obj)
 
@@ -153,7 +153,7 @@ class PerformanceBenchmarker:
                 return {
                     "data": f"heavy_data_{index}" * 100,
                     "metadata": {"created": time.time(), "index": index},
-                    "payload": list[t.Any](range(100)),
+                    "payload": list(range(100)),
                 }
 
             lazy_obj = LazyLoader(create_heavy_object, f"heavy_object_{i}")
@@ -298,5 +298,27 @@ class PerformanceBenchmarker:
         self._logger.info(f"Exported benchmark results to {output_path}")
 
 
+class PerformanceBenchmarkService:
+    """Service wrapper for performance benchmarking in workflow orchestration."""
+
+    def __init__(self, console, pkg_path):
+        self._console = console
+        self._pkg_path = pkg_path
+        self._benchmarker = PerformanceBenchmarker()
+        self._logger = get_logger("crackerjack.benchmark_service")
+
+    async def run_benchmark_suite(self) -> BenchmarkSuite | None:
+        """Run comprehensive benchmark suite and return results."""
+        try:
+            return await self._benchmarker.run_comprehensive_benchmark()
+        except Exception as e:
+            self._logger.warning(f"Benchmark suite failed: {e}")
+            return None
+
+    def export_results(self, suite: BenchmarkSuite, output_path: Path) -> None:
+        """Export benchmark results to file."""
+        self._benchmarker.export_benchmark_results(suite, output_path)
+
+
 def get_benchmarker() -> PerformanceBenchmarker:
     return PerformanceBenchmarker()

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/services/performance_cache.py

@@ -140,7 +140,7 @@ class PerformanceCache:
         ttl_seconds: int | None = None,
         invalidation_keys: builtins.set[str] | None = None,
     ) -> None:
-        self.set[t.Any](key, value, ttl_seconds, invalidation_keys)
+        self.set(key, value, ttl_seconds, invalidation_keys)
 
     def invalidate(self, invalidation_key: str) -> int:
         with self._lock:

{crackerjack-0.33.12 → crackerjack-0.34.0}/crackerjack/tools/validate_regex_patterns.py

@@ -166,15 +166,15 @@ def main(file_paths: list[str]) -> int:
     if exit_code == 0:
         print("✅ All regex patterns validated successfully!")
     else:
-        print("\n" + "=" * 80)
+        print("\n" + "=" * 74)
         print("REGEX VALIDATION FAILED")
-        print("=" * 80)
+        print("=" * 74)
         print("To fix these issues: ")
         print("1. Use patterns from crackerjack.services.regex_patterns")
         print("2. Add new patterns to SAFE_PATTERNS with comprehensive tests")
         print("3. Use '# REGEX OK: reason' comment for legitimate exceptions")
         print("4. Fix \\g<1> replacement syntax (no spaces)")
-        print("=" * 80)
+        print("=" * 74)
 
     return exit_code
 

{crackerjack-0.33.12 → crackerjack-0.34.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "crackerjack"
-version = "0.33.12"
+version = "0.34.0"
 description = "Crackerjack Python project management tool"
 readme = "README.md"
 authors = [

{crackerjack-0.33.12 → crackerjack-0.34.0}/tests/test_async_hook_executor.py

@@ -20,7 +20,7 @@ from crackerjack.models.task import HookResult
 class TestAsyncHookExecutor:
     @pytest.fixture
     def console(self):
-        return Console(force_terminal=False, width=80)
+        return Console(force_terminal=False, width=74)
 
     @pytest.fixture
     def pkg_path(self, tmp_path):

{crackerjack-0.33.12 → crackerjack-0.34.0}/tests/test_structured_errors.py

@@ -125,7 +125,7 @@ class TestErrorHandlingIntegration:
             recovery="Try running with - - verbose",
         )
         output_io = io.StringIO()
-        console = Console(file=output_io, width=80)
+        console = Console(file=output_io, width=74)
         with patch("sys.exit"):
             handle_error(error, console, verbose=True)
         output = output_io.getvalue()
@@ -144,7 +144,7 @@ class TestErrorHandlingIntegration:
             recovery="Check command syntax",
         )
         output_io = io.StringIO()
-        console = Console(file=output_io, width=80)
+        console = Console(file=output_io, width=74)
         with patch("sys.exit"):
             handle_error(error, console, verbose=True, ai_agent=True)
         output = output_io.getvalue()