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

crackerjack/mcp/tools/core_tools.py

@@ -1,5 +1,8 @@
 import typing as t
 
+from acb.depends import depends
+
+from crackerjack.config import CrackerjackSettings
 from crackerjack.mcp.context import MCPServerContext, get_context
 from crackerjack.mcp.rate_limiter import RateLimitMiddleware
 from crackerjack.services.input_validator import (
@@ -9,7 +12,6 @@ from crackerjack.services.input_validator import (
 
 if t.TYPE_CHECKING:
     from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
-    from crackerjack.models.config import WorkflowOptions
 
 
 async def create_task_with_subagent(
@@ -141,26 +143,38 @@ def _validate_kwargs_argument(
     return extra_kwargs
 
 
-def _configure_stage_options(stage: str) -> "WorkflowOptions":
-    from crackerjack.models.config import WorkflowOptions
+def _configure_stage_options(stage: str) -> CrackerjackSettings:
+    """Configure settings for a specific stage using ACB dependency injection.
+
+    Note: Returns a copy of global settings with stage-specific overrides.
+    The global settings remain unchanged.
+    """
+    # Get base settings from DI
+    base_settings = depends.get_sync(CrackerjackSettings)
+
+    # Create a new settings instance with stage-specific values
+    # We copy the base settings and override specific fields
+    settings_dict = base_settings.model_dump()
 
-    options = WorkflowOptions()
     if stage in {"fast", "comprehensive"}:
-        options.hooks.skip_hooks = False
+        settings_dict["skip_hooks"] = False
     elif stage == "tests":
-        options.testing.test = True
+        settings_dict["run_tests"] = (
+            True  # Note: field renamed from 'test' to 'run_tests'
+        )
     elif stage == "cleaning":
-        options.cleaning.clean = True
+        settings_dict["clean"] = True
     elif stage == "init":
-        options.hooks.skip_hooks = True
-    return options
+        settings_dict["skip_hooks"] = True
+
+    return CrackerjackSettings(**settings_dict)
 
 
 def _execute_stage(
-    orchestrator: "WorkflowOrchestrator", stage: str, options: "WorkflowOptions"
+    orchestrator: "WorkflowOrchestrator", stage: str, settings: CrackerjackSettings
 ) -> bool:
-    # Convert WorkflowOptions to OptionsProtocol
-    adapted_options = _adapt_workflow_options_to_protocol(options)
+    # Convert CrackerjackSettings to OptionsProtocol
+    adapted_options = _adapt_settings_to_protocol(settings)
 
     if stage == "fast":
         return orchestrator.run_fast_hooks_only(adapted_options)
@@ -173,122 +187,126 @@ def _execute_stage(
     return False
 
 
-def _adapt_workflow_options_to_protocol(options: "WorkflowOptions") -> t.Any:
-    """Adapt WorkflowOptions to match OptionsProtocol."""
-    return _AdaptedOptions(options)  # type: ignore
+def _adapt_settings_to_protocol(settings: CrackerjackSettings) -> t.Any:
+    """Adapt CrackerjackSettings to match OptionsProtocol."""
+    return _AdaptedOptions(settings)  # type: ignore
 
 
 class _AdaptedOptions:
-    """Adapter class to convert WorkflowOptions to OptionsProtocol."""
+    """Adapter class to convert CrackerjackSettings to OptionsProtocol.
+
+    Since CrackerjackSettings uses flat field structure, this adapter
+    is much simpler than the old nested WorkflowOptions version.
+    """
 
-    def __init__(self, opts: "WorkflowOptions"):
-        self.opts = opts
+    def __init__(self, settings: CrackerjackSettings):
+        self.settings = settings
 
     # Git properties
     @property
     def commit(self) -> bool:
-        return getattr(self.opts.git, "commit", False)
+        return self.settings.commit
 
     @property
     def create_pr(self) -> bool:
-        return getattr(self.opts.git, "create_pr", False)
+        return self.settings.create_pr
 
     # Execution properties
     @property
     def interactive(self) -> bool:
-        return getattr(self.opts.execution, "interactive", False)
+        return self.settings.interactive
 
     @property
     def no_config_updates(self) -> bool:
-        return getattr(self.opts.execution, "no_config_updates", False)
+        return self.settings.no_config_updates
 
     @property
     def verbose(self) -> bool:
-        return getattr(self.opts.execution, "verbose", False)
+        return self.settings.verbose
 
     @property
     def async_mode(self) -> bool:
-        return getattr(self.opts.execution, "async_mode", False)
+        return self.settings.async_mode
 
     # Testing properties
     @property
     def test(self) -> bool:
-        return getattr(self.opts.testing, "test", False)
+        return self.settings.run_tests  # Note: Field renamed in CrackerjackSettings
 
     @property
     def benchmark(self) -> bool:
-        return getattr(self.opts.testing, "benchmark", False)
+        return self.settings.benchmark
 
     @property
     def test_workers(self) -> int:
-        return getattr(self.opts.testing, "test_workers", 0)
+        return self.settings.test_workers
 
     @property
     def test_timeout(self) -> int:
-        return getattr(self.opts.testing, "test_timeout", 0)
+        return self.settings.test_timeout
 
     # Publishing properties
     @property
     def publish(self) -> t.Any | None:
-        return getattr(self.opts.publishing, "publish", None)
+        return self.settings.publish_version
 
     @property
     def bump(self) -> t.Any | None:
-        return getattr(self.opts.publishing, "bump", None)
+        return self.settings.bump_version
 
     @property
     def all(self) -> t.Any | None:
-        return getattr(self.opts.publishing, "all", None)
+        return self.settings.all_workflow
 
     @property
     def no_git_tags(self) -> bool:
-        return getattr(self.opts.publishing, "no_git_tags", False)
+        return self.settings.no_git_tags
 
     @property
     def skip_version_check(self) -> bool:
-        return getattr(self.opts.publishing, "skip_version_check", False)
+        return self.settings.skip_version_check
 
     # AI properties
     @property
     def ai_agent(self) -> bool:
-        return getattr(self.opts.ai, "ai_agent", False)
+        return self.settings.ai_agent
 
     @property
     def start_mcp_server(self) -> bool:
-        return getattr(self.opts.ai, "start_mcp_server", False)
+        return self.settings.start_mcp_server
 
     # Hook properties
     @property
     def skip_hooks(self) -> bool:
-        return getattr(self.opts.hooks, "skip_hooks", False)
+        return self.settings.skip_hooks
 
     @property
     def update_precommit(self) -> bool:
-        return getattr(self.opts.hooks, "update_precommit", False)
+        return self.settings.update_precommit
 
     @property
     def experimental_hooks(self) -> bool:
-        return getattr(self.opts.hooks, "experimental_hooks", False)
+        return self.settings.experimental_hooks
 
     @property
     def enable_pyrefly(self) -> bool:
-        return getattr(self.opts.hooks, "enable_pyrefly", False)
+        return self.settings.enable_pyrefly
 
     @property
     def enable_ty(self) -> bool:
-        return getattr(self.opts.hooks, "enable_ty", False)
+        return self.settings.enable_ty
 
     # Cleaning properties
     @property
     def clean(self) -> bool:
-        return getattr(self.opts.cleaning, "clean", False)
+        return self.settings.clean
 
     # Progress properties
     @property
     def track_progress(self) -> bool:
-        return getattr(self.opts.progress, "track_progress", False)
+        return self.settings.progress_enabled
 
-    # Default/static properties
+    # Default/static properties (not in settings, keep defaults)
     @property
     def cleanup(self) -> t.Any | None:
         return None
@@ -299,7 +317,7 @@ class _AdaptedOptions:
 
     @property
     def coverage(self) -> bool:
-        return False
+        return self.settings.coverage_enabled
 
     @property
     def keep_releases(self) -> int:
@@ -310,21 +328,26 @@ class _AdaptedOptions:
         return False
 
 
-def _execute_init_stage(orchestrator: "WorkflowOrchestrator") -> bool:
+from acb.console import Console
+from acb.depends import Inject
+
+from crackerjack.services.filesystem import FileSystemService
+from crackerjack.services.git import GitService
+from crackerjack.services.initialization import InitializationService
+
+
+def _execute_init_stage(
+    orchestrator: "WorkflowOrchestrator", console: Inject[Console]
+) -> bool:
     try:
         from pathlib import Path
 
-        from crackerjack.services.filesystem import FileSystemService
-        from crackerjack.services.git import GitService
-        from crackerjack.services.initialization import InitializationService
-
-        console = orchestrator.console
         pkg_path = orchestrator.pkg_path
 
         filesystem = FileSystemService()
-        git_service = GitService(console, pkg_path)
+        git_service = GitService(pkg_path)
 
-        init_service = InitializationService(console, filesystem, git_service, pkg_path)
+        init_service = InitializationService(filesystem, git_service, pkg_path)
 
         results = init_service.initialize_project_full(target_path=Path.cwd())
 

crackerjack/mcp/tools/execution_tools.py

@@ -17,37 +17,91 @@ def register_execution_tools(mcp_app: t.Any) -> None:
 def _register_execute_crackerjack_tool(mcp_app: t.Any) -> None:
     @mcp_app.tool()  # type: ignore[misc]
     async def execute_crackerjack(args: str, kwargs: str) -> str:
-        context = get_context()
-
-        validation_error = await _validate_context_and_rate_limit(context)
-        if validation_error:
-            return validation_error
-
-        kwargs_result = _parse_kwargs(kwargs)
-        if "error" in kwargs_result:
-            return json.dumps(kwargs_result)
-
-        extra_kwargs = kwargs_result["kwargs"]
+        try:
+            context = get_context()
+            validation_error = await _handle_context_validation(context)
+            if validation_error:
+                return validation_error
 
-        if "execution_timeout" not in extra_kwargs:
-            if extra_kwargs.get("test", False) or extra_kwargs.get("testing", False):
-                extra_kwargs["execution_timeout"] = 1200
-            else:
-                extra_kwargs["execution_timeout"] = 900
+            kwargs_result = _parse_kwargs(kwargs)
+            if "error" in kwargs_result:
+                return json.dumps(kwargs_result)
 
-        try:
+            extra_kwargs = _prepare_execution_kwargs(kwargs_result["kwargs"])
             result = await execute_crackerjack_workflow(args, extra_kwargs)
             return json.dumps(result, indent=2)
+        except TypeError as e:
+            return _handle_type_error(e)
         except Exception as e:
+            return _handle_general_error(e)
+
+
+async def _handle_context_validation(context: t.Any) -> str | None:
+    """Handle context validation with proper error handling."""
+    from datetime import datetime
+
+    try:
+        validation_error = await _validate_context_and_rate_limit(context)
+        if validation_error:
+            return validation_error
+        return None
+    except TypeError as e:
+        if "NoneType" in str(e) and "await" in str(e):
             return json.dumps(
                 {
                     "status": "failed",
-                    "error": f"Execution failed: {e}",
-                    "timestamp": context.get_current_time()
-                    if hasattr(context, "get_current_time")
-                    else None,
+                    "error": "Context validation failed: rate limiter returned None. "
+                    "MCP server may not be properly initialized.",
+                    "timestamp": datetime.now().isoformat(),
+                    "details": str(e),
                 }
             )
+        raise
+
+
+def _prepare_execution_kwargs(kwargs: dict[str, t.Any]) -> dict[str, t.Any]:
+    """Prepare execution kwargs with appropriate timeout defaults."""
+    if "execution_timeout" not in kwargs:
+        if kwargs.get("test", False) or kwargs.get("testing", False):
+            kwargs["execution_timeout"] = 1200
+        else:
+            kwargs["execution_timeout"] = 900
+    return kwargs
+
+
+def _handle_type_error(error: TypeError) -> str:
+    """Handle TypeError with specific async execution error details."""
+    import traceback
+    from datetime import datetime
+
+    if "NoneType" in str(error) and "await" in str(error):
+        return json.dumps(
+            {
+                "status": "failed",
+                "error": f"Async execution error: A function returned None instead of an awaitable. {error}",
+                "traceback": traceback.format_exc(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    raise error
+
+
+def _handle_general_error(error: Exception) -> str:
+    """Handle general execution errors with traceback."""
+    import traceback
+    from datetime import datetime
+
+    context = get_context()
+    return json.dumps(
+        {
+            "status": "failed",
+            "error": f"Execution failed: {error}",
+            "traceback": traceback.format_exc(),
+            "timestamp": context.get_current_time()
+            if context and hasattr(context, "get_current_time")
+            else datetime.now().isoformat(),
+        }
+    )
 
 
 def _register_smart_error_analysis_tool(mcp_app: t.Any) -> None:
@@ -153,20 +207,22 @@ def _parse_init_arguments(args: str, kwargs: str) -> tuple[t.Any, bool, str | No
 
 
 def _execute_initialization(target_path: t.Any, force: bool) -> dict[str, t.Any]:
-    from rich.console import Console
-
-    from crackerjack.services.initialization import InitializationService
-
-    console = Console()
+    from acb.console import Console
+    from acb.depends import Inject, depends
 
     from crackerjack.services.filesystem import FileSystemService
     from crackerjack.services.git import GitService
+    from crackerjack.services.initialization import InitializationService
 
-    filesystem = FileSystemService()
-    git_service = GitService(console)
-    return InitializationService(
-        console, filesystem, git_service, target_path
-    ).initialize_project_full(force=force)
+    @depends.inject
+    def _execute_initialization(
+        target_path: t.Any, force: bool, console: Inject[Console]
+    ) -> dict[str, t.Any]:
+        filesystem = FileSystemService()
+        git_service = GitService(target_path)
+        return InitializationService(
+            filesystem, git_service, target_path
+        ).initialize_project_full(force=force)
 
 
 def _create_init_error_response(message: str) -> str:

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,
         }
@@ -181,7 +181,7 @@ async def get_smart_agent_recommendation(
                     {"error": str(e)}, indent=2
                 )
 
-        logger.debug(f"Generated recommendation for task: {task_description[:50]}...")
+        logger.debug(f"Generated recommendation for task: {task_description[:50]}")
         return response
 
     except Exception as e:

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": [],