crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/core/async_workflow_orchestrator.py

@@ -1,9 +1,11 @@
 import asyncio
-import logging
 import time
 import typing as t
+from contextlib import suppress
 from pathlib import Path
 
+from acb.depends import Inject, depends
+from acb.logger import Logger
 from rich.console import Console
 
 from crackerjack.agents.base import FixResult, Issue, IssueType, Priority
@@ -15,9 +17,11 @@ from .timeout_manager import TimeoutStrategy, get_timeout_manager
 
 
 class AsyncWorkflowPipeline:
+    @depends.inject
     def __init__(
         self,
-        console: Console,
+        logger: Inject[Logger],
+        console: Inject[Console],
         pkg_path: Path,
         session: SessionCoordinator,
         phases: PhaseCoordinator,
@@ -26,7 +30,7 @@ class AsyncWorkflowPipeline:
         self.pkg_path = pkg_path
         self.session = session
         self.phases = phases
-        self.logger = logging.getLogger("crackerjack.async_pipeline")
+        self.logger = logger
         self.timeout_manager = get_timeout_manager()
         self._active_tasks: list[asyncio.Task[t.Any]] = []
         self.resource_context: t.Any | None = None
@@ -60,7 +64,7 @@ class AsyncWorkflowPipeline:
     async def _execute_workflow_phases_async(self, options: OptionsProtocol) -> bool:
         success = True
 
-        self.phases.run_configuration_phase(options)
+        self.phases.run_configuration_phase(options)  # type: ignore[arg-type]
 
         if not await self._execute_cleaning_phase_async(options):
             success = False
@@ -73,12 +77,12 @@ class AsyncWorkflowPipeline:
 
             return False
 
-        if not self.phases.run_publishing_phase(options):
+        if not self.phases.run_publishing_phase(options):  # type: ignore[arg-type]
             success = False
             self.session.fail_task("workflow", "Publishing failed")
             return False
 
-        if not self.phases.run_commit_phase(options):
+        if not self.phases.run_commit_phase(options):  # type: ignore[arg-type]
             success = False
 
         return success
@@ -113,7 +117,7 @@ class AsyncWorkflowPipeline:
             asyncio.to_thread(self.phases.run_cleaning_phase, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.RETRY_WITH_BACKOFF,
         )
-        return bool(result)
+        return bool(result)  # type: ignore[return-value]
 
     async def _execute_quality_phase_async(self, options: OptionsProtocol) -> bool:
         if hasattr(options, "fast") and options.fast:
@@ -188,13 +192,12 @@ class AsyncWorkflowPipeline:
 
         return done, pending
 
-    async def _cleanup_pending_tasks(self, pending: set[asyncio.Task[t.Any]]) -> None:
+    @staticmethod
+    async def _cleanup_pending_tasks(pending: set[asyncio.Task[t.Any]]) -> None:
         for task in pending:
             task.cancel()
-            try:
+            with suppress(asyncio.CancelledError):
                 await task
-            except asyncio.CancelledError:
-                pass
 
     async def _process_task_results(
         self,
@@ -265,7 +268,7 @@ class AsyncWorkflowPipeline:
             asyncio.to_thread(self.phases.run_fast_hooks_only, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.RETRY_WITH_BACKOFF,
         )
-        return bool(result)
+        return bool(result)  # type: ignore[return-value]
 
     async def _run_comprehensive_hooks_async(self, options: OptionsProtocol) -> bool:
         result = await self.timeout_manager.with_timeout(
@@ -273,7 +276,7 @@ class AsyncWorkflowPipeline:
             asyncio.to_thread(self.phases.run_comprehensive_hooks_only, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
         )
-        return bool(result)
+        return bool(result)  # type: ignore[return-value]
 
     async def _run_hooks_phase_async(self, options: OptionsProtocol) -> bool:
         result = await self.timeout_manager.with_timeout(
@@ -281,7 +284,7 @@ class AsyncWorkflowPipeline:
             asyncio.to_thread(self.phases.run_hooks_phase, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
         )
-        return bool(result)
+        return bool(result)  # type: ignore[return-value]
 
     async def _run_testing_phase_async(self, options: OptionsProtocol) -> bool:
         result = await self.timeout_manager.with_timeout(
@@ -289,7 +292,7 @@ class AsyncWorkflowPipeline:
             asyncio.to_thread(self.phases.run_testing_phase, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
         )
-        return bool(result)
+        return bool(result)  # type: ignore[return-value]
 
     async def _execute_ai_agent_workflow_async(
         self, options: OptionsProtocol, max_iterations: int = 10
@@ -298,7 +301,7 @@ class AsyncWorkflowPipeline:
             f"🤖 Starting AI Agent workflow (max {max_iterations} iterations)"
         )
 
-        self.phases.run_configuration_phase(options)
+        self.phases.run_configuration_phase(options)  # type: ignore[arg-type]
 
         if not await self._execute_cleaning_phase_async(options):
             self.session.fail_task("workflow", "Cleaning phase failed")
@@ -431,7 +434,8 @@ class AsyncWorkflowPipeline:
             issue, IssueType.FORMATTING, Priority.MEDIUM, "refurb"
         )
 
-    def _parse_single_test_issue(self, issue: str) -> Issue:
+    @staticmethod
+    def _parse_single_test_issue(issue: str) -> Issue:
         import uuid
 
         from crackerjack.agents.base import Issue, IssueType, Priority
@@ -450,8 +454,9 @@ class AsyncWorkflowPipeline:
             stage="test",
         )
 
+    @staticmethod
     def _create_generic_issue(
-        self, issue: str, issue_type: IssueType, priority: Priority, stage: str
+        issue: str, issue_type: IssueType, priority: Priority, stage: str
     ) -> Issue:
         import uuid
 
@@ -467,18 +472,18 @@ class AsyncWorkflowPipeline:
         )
 
     async def _run_final_workflow_phases(self, options: OptionsProtocol) -> bool:
-        if not self.phases.run_publishing_phase(options):
+        if not self.phases.run_publishing_phase(options):  # type: ignore[arg-type]
             self.session.fail_task("workflow", "Publishing failed")
             return False
 
-        if not self.phases.run_commit_phase(options):
+        if not self.phases.run_commit_phase(options):  # type: ignore[arg-type]
             self.session.fail_task("workflow", "Commit failed")
             return False
 
         return True
 
     async def _run_fast_hooks_with_retry_async(self, options: OptionsProtocol) -> bool:
-        return await asyncio.to_thread(self.phases.run_fast_hooks_only, options)
+        return await asyncio.to_thread(self.phases.run_fast_hooks_only, options)  # type: ignore[arg-type]
 
     async def _collect_test_issues_async(self, options: OptionsProtocol) -> list[str]:
         if not options.test:
@@ -573,10 +578,11 @@ class AsyncWorkflowPipeline:
 
     def _create_agent_coordinator(self) -> t.Any:
         from crackerjack.agents.base import AgentContext
-        from crackerjack.agents.coordinator import AgentCoordinator
+        from crackerjack.agents.enhanced_coordinator import create_enhanced_coordinator
 
         context = AgentContext(project_path=self.pkg_path)
-        return AgentCoordinator(context)
+        # Use enhanced coordinator with Claude Code agent integration
+        return create_enhanced_coordinator(context=context, enable_external_agents=True)
 
     def _report_fix_results(self, fix_result: FixResult, iteration: int) -> None:
         if fix_result.success:
@@ -602,24 +608,34 @@ class AsyncWorkflowPipeline:
 
 
 class AsyncWorkflowOrchestrator:
+    @depends.inject
     def __init__(
         self,
-        console: Console | None = None,
+        logger: Inject[Logger],
+        console: Inject[Console],
         pkg_path: Path | None = None,
         dry_run: bool = False,
         web_job_id: str | None = None,
         verbose: bool = False,
         debug: bool = False,
+        changed_only: bool = False,
     ) -> None:
-        self.console = console or Console(force_terminal=True)
+        # Initialize console and pkg_path first
+        self.console = console
         self.pkg_path = pkg_path or Path.cwd()
         self.dry_run = dry_run
         self.web_job_id = web_job_id
         self.verbose = verbose
         self.debug = debug
+        self.changed_only = changed_only
 
-        self._initialize_logging()
+        # Configure ACB dependency injection using native patterns
+        from acb.depends import depends
+
+        # Register core dependencies directly with ACB
+        depends.set(Path, self.pkg_path)
 
+        # Import protocols for retrieving dependencies via ACB
         from crackerjack.models.protocols import (
             ConfigMergeServiceProtocol,
             FileSystemInterface,
@@ -629,48 +645,50 @@ class AsyncWorkflowOrchestrator:
             TestManagerProtocol,
         )
 
-        from .enhanced_container import create_enhanced_container
+        # Setup services with ACB DI (reuse from WorkflowOrchestrator)
+        from .workflow_orchestrator import WorkflowOrchestrator
 
-        self.container = create_enhanced_container(
-            console=self.console,
-            pkg_path=self.pkg_path,
-            dry_run=self.dry_run,
-        )
+        # Use a temporary orchestrator instance just for service setup
+        temp_orch = WorkflowOrchestrator.__new__(WorkflowOrchestrator)
+        temp_orch.console = self.console
+        temp_orch.pkg_path = self.pkg_path
+        temp_orch.verbose = self.verbose
+        temp_orch._setup_acb_services()
+
+        self._initialize_logging()
+
+        self.logger = logger
 
+        # Create coordinators - dependencies retrieved via ACB's depends.get_sync()
         self.session = SessionCoordinator(self.console, self.pkg_path, self.web_job_id)
         self.phases = PhaseCoordinator(
             console=self.console,
             pkg_path=self.pkg_path,
             session=self.session,
-            filesystem=self.container.get(FileSystemInterface),
-            git_service=self.container.get(GitInterface),
-            hook_manager=self.container.get(HookManager),
-            test_manager=self.container.get(TestManagerProtocol),
-            publish_manager=self.container.get(PublishManager),
-            config_merge_service=self.container.get(ConfigMergeServiceProtocol),
+            filesystem=depends.get_sync(FileSystemInterface),
+            git_service=depends.get_sync(GitInterface),
+            hook_manager=depends.get_sync(HookManager),
+            test_manager=depends.get_sync(TestManagerProtocol),
+            publish_manager=depends.get_sync(PublishManager),
+            config_merge_service=depends.get_sync(ConfigMergeServiceProtocol),
         )
 
         self.async_pipeline = AsyncWorkflowPipeline(
-            console=self.console,
             pkg_path=self.pkg_path,
             session=self.session,
             phases=self.phases,
         )
 
-        self.logger = logging.getLogger("crackerjack.async_orchestrator")
-
     def _initialize_logging(self) -> None:
         from crackerjack.services.log_manager import get_log_manager
-        from crackerjack.services.logging import setup_structured_logging
 
         log_manager = get_log_manager()
         session_id = getattr(self, "web_job_id", None) or str(int(time.time()))[:8]
         debug_log_file = log_manager.create_debug_log_file(session_id)
 
         log_level = "DEBUG" if self.debug else "INFO"
-        setup_structured_logging(
-            level=log_level, json_output=False, log_file=debug_log_file
-        )
+        self.logger.set_level(log_level)
+        self.logger.add_file_handler(debug_log_file)
 
     async def run_complete_workflow_async(self, options: OptionsProtocol) -> bool:
         return await self.async_pipeline.run_complete_workflow_async(options)
@@ -679,28 +697,36 @@ class AsyncWorkflowOrchestrator:
         return asyncio.run(self.run_complete_workflow_async(options))
 
     def run_cleaning_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_cleaning_phase(options)
+        result = self.phases.run_cleaning_phase(options)  # type: ignore[arg-type]
+        return bool(result)
 
     def run_fast_hooks_only(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_fast_hooks_only(options)
+        result = self.phases.run_fast_hooks_only(options)  # type: ignore[arg-type]
+        return bool(result)
 
     def run_comprehensive_hooks_only(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_comprehensive_hooks_only(options)
+        result = self.phases.run_comprehensive_hooks_only(options)  # type: ignore[arg-type]
+        return bool(result)
 
     def run_hooks_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_hooks_phase(options)
+        result = self.phases.run_hooks_phase(options)  # type: ignore[arg-type]
+        return bool(result)
 
     def run_testing_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_testing_phase(options)
+        result = self.phases.run_testing_phase(options)  # type: ignore[arg-type]
+        return bool(result)
 
     def run_publishing_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_publishing_phase(options)
+        result = self.phases.run_publishing_phase(options)  # type: ignore[arg-type]
+        return bool(result)
 
     def run_commit_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_commit_phase(options)
+        result = self.phases.run_commit_phase(options)  # type: ignore[arg-type]
+        return bool(result)
 
     def run_configuration_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_configuration_phase(options)
+        result = self.phases.run_configuration_phase(options)  # type: ignore[arg-type]
+        return bool(result)
 
     def _cleanup_resources(self) -> None:
         self.session.cleanup_resources()

crackerjack/core/autofix_coordinator.py

@@ -1,18 +1,31 @@
 import subprocess
+from contextlib import suppress
 from pathlib import Path
 
-from rich.console import Console
-
-from crackerjack.services.logging import get_logger
+from acb.console import Console
+from acb.depends import depends
+from acb.logger import Logger
 
 
 class AutofixCoordinator:
-    def __init__(self, console: Console, pkg_path: Path) -> None:
-        self.console = console
-        self.pkg_path = pkg_path
-        self.logger = get_logger("crackerjack.autofix")
-
-        setattr(self.logger, "name", "crackerjack.autofix")
+    def __init__(
+        self,
+        console: object | None = None,
+        pkg_path: Path | None = None,
+        logger: object | None = None,
+    ) -> None:
+        # Allow explicit injection from tests; fall back to DI when not provided
+        self.console = console or depends.get_sync(Console)
+        self.pkg_path = pkg_path or Path.cwd()
+        # Bind logger context with name for tracing
+        _logger = logger or depends.get_sync(Logger)
+        if hasattr(_logger, "bind"):
+            self.logger = _logger.bind(logger="crackerjack.autofix")
+        else:
+            self.logger = _logger
+        if not hasattr(self.logger, "name"):
+            with suppress(Exception):
+                setattr(self.logger, "name", "crackerjack.autofix")
 
     def apply_autofix_for_hooks(self, mode: str, hook_results: list[object]) -> bool:
         try:

crackerjack/core/container.py

@@ -1,7 +1,8 @@
 import typing as t
 from pathlib import Path
 
-from rich.console import Console
+from acb import console as acb_console
+from acb.console import Console
 
 from crackerjack.models.protocols import (
     FileSystemInterface,
@@ -44,7 +45,7 @@ class DependencyContainer:
         verbose: bool = False,
     ) -> "DependencyContainer":
         if console is None:
-            console = Console(force_terminal=True)
+            console = acb_console
 
         if pkg_path is None:
             pkg_path = Path.cwd()
@@ -57,7 +58,7 @@ class DependencyContainer:
 
         self.register_transient(
             GitInterface,
-            lambda: GitService(console=console, pkg_path=pkg_path),
+            lambda: GitService(pkg_path=pkg_path),
         )
 
         from crackerjack.managers.hook_manager import HookManagerImpl
@@ -78,24 +79,24 @@ class DependencyContainer:
 
         from crackerjack.managers.publish_manager import PublishManagerImpl
 
+        # Use factory without parameters to trigger @depends.inject decorator
+        # The decorator will inject all dependencies from the DI container
         self.register_transient(
             PublishManager,
-            lambda: PublishManagerImpl(
-                console=console,
-                pkg_path=pkg_path,
-                dry_run=dry_run,
-            ),
+            PublishManagerImpl,
         )
 
         return self
 
 
 def create_container(
-    console: Console | None = None,
+    console: Console | None = None,  # defaults to acb_console if None
     pkg_path: Path | None = None,
     dry_run: bool = False,
     verbose: bool = False,
 ) -> DependencyContainer:
+    if console is None:
+        console = acb_console
     return DependencyContainer().create_default_container(
         console=console,
         pkg_path=pkg_path,

crackerjack/core/enhanced_container.py

@@ -44,7 +44,7 @@ class ServiceDescriptor:
     created_count: int = 0
     dependencies: list[type] = field(default_factory=list)
 
-    def __post_init__(self) -> None:
+    def __post_init__(self):
         if self.implementation is self.factory is self.instance is None:
             msg = "Must provide either implementation, factory, or instance"
             raise ValueError(msg)
@@ -300,7 +300,7 @@ class EnhancedDependencyContainer:
         self._current_scope = scope
 
     def get_service_info(self) -> dict[str, Any]:
-        info: dict[str, Any] = {}
+        info = {}
 
         with self._lock:
             for key, descriptor in self._services.items():
@@ -391,7 +391,7 @@ class EnhancedDependencyContainer:
     def _get_service_key(self, interface: type) -> str:
         return f"{interface.__module__}.{interface.__name__}"
 
-    def __enter__(self) -> "EnhancedDependencyContainer":
+    def __enter__(self):
         return self
 
     def __exit__(
@@ -463,13 +463,11 @@ class ServiceCollectionBuilder:
 
         from crackerjack.managers.publish_manager import PublishManagerImpl
 
+        # Use factory without parameters to trigger @depends.inject decorator
+        # The decorator will inject all dependencies from the DI container
         self.container.register_transient(
             PublishManager,
-            factory=lambda: PublishManagerImpl(
-                console=console,
-                pkg_path=pkg_path,
-                dry_run=self.dry_run,
-            ),
+            factory=PublishManagerImpl,
         )
 
         return self
@@ -515,7 +513,9 @@ class ServiceCollectionBuilder:
 
             filesystem = FileSystemService()
             git_service = GitService(console, pkg_path)
-            return InitializationService(console, filesystem, git_service, pkg_path)
+            service = InitializationService(console, filesystem, git_service, pkg_path)
+            # Cast to protocol type to ensure correct typing
+            return t.cast(InitializationServiceProtocol, service)
 
         self.container.register_transient(
             InitializationServiceProtocol,

crackerjack/core/performance.py

@@ -3,7 +3,7 @@ import time
 import typing as t
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
 
 
 class FileCache:

crackerjack/core/performance_monitor.py

@@ -7,7 +7,9 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from threading import Lock
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import depends
+from rich.panel import Panel
 from rich.table import Table
 
 logger = logging.getLogger("crackerjack.performance_monitor")
@@ -285,7 +287,7 @@ class AsyncPerformanceMonitor:
 
     def print_performance_report(self, console: Console | None = None) -> None:
         if console is None:
-            console = Console()
+            console = depends.get_sync(Console)
 
         console.print("\n[bold blue]🔍 Async Performance Monitor Report[/bold blue]")
         console.print("=" * 60)
@@ -318,7 +320,7 @@ class AsyncPerformanceMonitor:
                         str(metrics.timeout_calls),
                     )
 
-            console.print(table)
+            console.print(Panel(table, title="Operation Metrics", border_style="cyan"))
 
         alerts = self.get_performance_alerts()
         if alerts: