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

crackerjack/mcp/state.py

@@ -92,7 +92,9 @@ class SessionState:
 
 
 class StateManager:
-    def __init__(self, state_dir: Path | None = None, batched_saver=None) -> None:
+    def __init__(
+        self, state_dir: Path | None = None, batched_saver: t.Any | None = None
+    ) -> None:
         self._lock = asyncio.Lock()
         self.state_dir = state_dir or Path.home() / ".cache" / "crackerjack-mcp"
         self.state_dir.mkdir(exist_ok=True)
@@ -258,7 +260,7 @@ class StateManager:
         priority_counts = {}
         for priority in Priority:
             priority_counts[priority.value] = len(self.get_issues_by_priority(priority))
-        type_counts = {}
+        type_counts: dict[str, int] = {}
         for issue in issues:
             type_counts[issue.type] = type_counts.get(issue.type, 0) + 1
         stage_status = {}
@@ -351,14 +353,9 @@ class StateManager:
         return checkpoints
 
     def start_session(self) -> None:
-        """Start or initialize a session."""
-        # Session is already initialized in __init__, this is a no-op
-        # but provided for API compatibility
         self._save_state()
 
     def complete_session(self) -> None:
-        """Complete the current session."""
-        # Mark session as complete in metadata
         if not self.session_state.metadata:
             self.session_state.metadata = {}
         self.session_state.metadata["status"] = "completed"

crackerjack/mcp/task_manager.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class TaskInfo:
     task_id: str
-    task: asyncio.Task
+    task: asyncio.Task[t.Any]
     created_at: float
     description: str = ""
     timeout_seconds: float | None = None
@@ -25,7 +25,7 @@ class AsyncTaskManager:
         self.max_concurrent_tasks = max_concurrent_tasks
         self._tasks: dict[str, TaskInfo] = {}
         self._task_semaphore = asyncio.Semaphore(max_concurrent_tasks)
-        self._cleanup_task: asyncio.Task | None = None
+        self._cleanup_task: asyncio.Task[t.Any] | None = None
         self._running = False
         self._lock = asyncio.Lock()
 
@@ -61,11 +61,11 @@ class AsyncTaskManager:
 
     async def create_task(
         self,
-        coro: t.Coroutine,
+        coro: t.Coroutine[t.Any, t.Any, t.Any],
         task_id: str,
         description: str = "",
         timeout_seconds: float | None = None,
-    ) -> asyncio.Task:
+    ) -> asyncio.Task[t.Any]:
         async with self._lock:
             if task_id in self._tasks:
                 msg = f"Task {task_id} already exists"
@@ -100,7 +100,9 @@ class AsyncTaskManager:
             console.print(f"[blue]🚀 Task {task_id} created: {description}[ / blue]")
         return task
 
-    async def _wrap_task(self, coro: t.Coroutine, task_id: str) -> t.Any:
+    async def _wrap_task(
+        self, coro: t.Coroutine[t.Any, t.Any, t.Any], task_id: str
+    ) -> t.Any:
         try:
             async with self._task_semaphore:
                 result = await coro
@@ -185,11 +187,11 @@ class AsyncTaskManager:
     @asynccontextmanager
     async def managed_task(
         self,
-        coro: t.Coroutine,
+        coro: t.Coroutine[t.Any, t.Any, t.Any],
         task_id: str,
         description: str = "",
         timeout_seconds: float | None = None,
-    ):
+    ) -> t.AsyncGenerator[asyncio.Task[t.Any]]:
         task = await self.create_task(coro, task_id, description, timeout_seconds)
         try:
             yield task
@@ -201,7 +203,7 @@ class AsyncTaskManager:
 
     async def _cancel_all_tasks(self) -> None:
         async with self._lock:
-            tasks_to_cancel = list(self._tasks.values())
+            tasks_to_cancel = list[t.Any](self._tasks.values())
 
         if not tasks_to_cancel:
             return
@@ -240,7 +242,7 @@ class AsyncTaskManager:
     async def _cleanup_completed_tasks(self) -> None:
         async with self._lock:
             completed_tasks = []
-            for task_id, task_info in list(self._tasks.items()):
+            for task_id, task_info in list[t.Any](self._tasks.items()):
                 if task_info.task.done():
                     completed_tasks.append(task_id)
                     del self._tasks[task_id]

crackerjack/mcp/tools/core_tools.py

@@ -1,10 +1,16 @@
 import typing as t
 
-from crackerjack.mcp.context import get_context
+from crackerjack.mcp.context import MCPServerContext, get_context
+from crackerjack.mcp.rate_limiter import RateLimitMiddleware
 from crackerjack.services.input_validator import (
+    SecureInputValidator,
     get_input_validator,
 )
 
+if t.TYPE_CHECKING:
+    from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
+    from crackerjack.models.config import WorkflowOptions
+
 
 async def create_task_with_subagent(
     description: str,
@@ -12,10 +18,8 @@ async def create_task_with_subagent(
     subagent_type: str,
 ) -> dict[str, t.Any]:
     try:
-        # Input validation with security checks
         validator = get_input_validator()
 
-        # Validate description
         desc_result = validator.validate_command_args(description)
         if not desc_result.valid:
             return {
@@ -24,7 +28,6 @@ async def create_task_with_subagent(
                 "validation_type": desc_result.validation_type,
             }
 
-        # Validate prompt
         prompt_result = validator.validate_command_args(prompt)
         if not prompt_result.valid:
             return {
@@ -33,7 +36,6 @@ async def create_task_with_subagent(
                 "validation_type": prompt_result.validation_type,
             }
 
-        # Validate subagent_type (should be safe identifier)
         subagent_result = validator.sanitizer.sanitize_string(
             subagent_type, max_length=100, strict_alphanumeric=True
         )
@@ -44,7 +46,6 @@ async def create_task_with_subagent(
                 "validation_type": subagent_result.validation_type,
             }
 
-        # Use sanitized values
         sanitized_description = desc_result.sanitized_value or description
         sanitized_prompt = prompt_result.sanitized_value or prompt
         sanitized_subagent = subagent_result.sanitized_value
@@ -72,7 +73,9 @@ async def create_task_with_subagent(
         }
 
 
-async def _validate_stage_request(context, rate_limiter) -> str | None:
+async def _validate_stage_request(
+    context: MCPServerContext | None, rate_limiter: RateLimitMiddleware | None
+) -> str | None:
     if not context:
         return '{"error": "Server context not available", "success": false}'
 
@@ -83,17 +86,15 @@ async def _validate_stage_request(context, rate_limiter) -> str | None:
     return None
 
 
-def _parse_stage_args(args: str, kwargs: str) -> tuple[str, dict] | str:
+def _parse_stage_args(args: str, kwargs: str) -> tuple[str, dict[str, t.Any]] | str:
     try:
         validator = get_input_validator()
 
-        # Validate stage argument
         stage_validation = _validate_stage_argument(validator, args)
         if isinstance(stage_validation, str):
             return stage_validation
         stage = stage_validation
 
-        # Validate and parse kwargs
         kwargs_validation = _validate_kwargs_argument(validator, kwargs)
         if isinstance(kwargs_validation, str):
             return kwargs_validation
@@ -105,15 +106,14 @@ def _parse_stage_args(args: str, kwargs: str) -> tuple[str, dict] | str:
         return f'{{"error": "Stage argument parsing failed: {e}", "success": false}}'
 
 
-def _validate_stage_argument(validator, args: str) -> str:
-    """Validate and sanitize the stage argument."""
+def _validate_stage_argument(validator: SecureInputValidator, args: str) -> str:
     stage_result = validator.sanitizer.sanitize_string(
         args.strip(), max_length=50, strict_alphanumeric=True
     )
     if not stage_result.valid:
         return f'{{"error": "Invalid stage argument: {stage_result.error_message}", "success": false}}'
 
-    stage = stage_result.sanitized_value.lower()
+    stage: str = str(stage_result.sanitized_value).lower()
     valid_stages = {"fast", "comprehensive", "tests", "cleaning", "init"}
 
     if stage not in valid_stages:
@@ -122,9 +122,10 @@ def _validate_stage_argument(validator, args: str) -> str:
     return stage
 
 
-def _validate_kwargs_argument(validator, kwargs: str) -> dict | str:
-    """Validate and parse the kwargs argument."""
-    extra_kwargs = {}
+def _validate_kwargs_argument(
+    validator: SecureInputValidator, kwargs: str
+) -> dict[str, t.Any] | str:
+    extra_kwargs: dict[str, t.Any] = {}
     if not kwargs.strip():
         return extra_kwargs
 
@@ -134,7 +135,6 @@ def _validate_kwargs_argument(validator, kwargs: str) -> dict | str:
 
     extra_kwargs = kwargs_result.sanitized_value
 
-    # Additional validation on JSON structure
     if not isinstance(extra_kwargs, dict):
         return f'{{"error": "kwargs must be a JSON object, got {type(extra_kwargs).__name__}", "success": false}}'
 
@@ -146,31 +146,171 @@ def _configure_stage_options(stage: str) -> "WorkflowOptions":
 
     options = WorkflowOptions()
     if stage in {"fast", "comprehensive"}:
-        options.skip_hooks = False
+        options.hooks.skip_hooks = False
     elif stage == "tests":
         options.testing.test = True
     elif stage == "cleaning":
         options.cleaning.clean = True
     elif stage == "init":
-        options.skip_hooks = True
+        options.hooks.skip_hooks = True
     return options
 
 
-def _execute_stage(orchestrator, stage: str, options) -> bool:
+def _execute_stage(
+    orchestrator: "WorkflowOrchestrator", stage: str, options: "WorkflowOptions"
+) -> bool:
+    # Convert WorkflowOptions to OptionsProtocol
+    adapted_options = _adapt_workflow_options_to_protocol(options)
+
     if stage == "fast":
-        return orchestrator.run_fast_hooks_only(options)
+        return orchestrator.run_fast_hooks_only(adapted_options)
     if stage == "comprehensive":
-        return orchestrator.run_comprehensive_hooks_only(options)
+        return orchestrator.run_comprehensive_hooks_only(adapted_options)
     if stage == "tests":
-        return orchestrator.run_testing_phase(options)
+        return orchestrator.run_testing_phase(adapted_options)
     if stage == "cleaning":
-        return orchestrator.run_cleaning_phase(options)
-    if stage == "init":
-        return _execute_init_stage(orchestrator)
+        return orchestrator.run_cleaning_phase(adapted_options)
     return False
 
 
-def _execute_init_stage(orchestrator) -> bool:
+def _adapt_workflow_options_to_protocol(options: "WorkflowOptions") -> t.Any:
+    """Adapt WorkflowOptions to match OptionsProtocol."""
+    return _AdaptedOptions(options)  # type: ignore
+
+
+class _AdaptedOptions:
+    """Adapter class to convert WorkflowOptions to OptionsProtocol."""
+
+    def __init__(self, opts: "WorkflowOptions"):
+        self.opts = opts
+
+    # Git properties
+    @property
+    def commit(self) -> bool:
+        return getattr(self.opts.git, "commit", False)
+
+    @property
+    def create_pr(self) -> bool:
+        return getattr(self.opts.git, "create_pr", False)
+
+    # Execution properties
+    @property
+    def interactive(self) -> bool:
+        return getattr(self.opts.execution, "interactive", False)
+
+    @property
+    def no_config_updates(self) -> bool:
+        return getattr(self.opts.execution, "no_config_updates", False)
+
+    @property
+    def verbose(self) -> bool:
+        return getattr(self.opts.execution, "verbose", False)
+
+    @property
+    def async_mode(self) -> bool:
+        return getattr(self.opts.execution, "async_mode", False)
+
+    # Testing properties
+    @property
+    def test(self) -> bool:
+        return getattr(self.opts.testing, "test", False)
+
+    @property
+    def benchmark(self) -> bool:
+        return getattr(self.opts.testing, "benchmark", False)
+
+    @property
+    def test_workers(self) -> int:
+        return getattr(self.opts.testing, "test_workers", 0)
+
+    @property
+    def test_timeout(self) -> int:
+        return getattr(self.opts.testing, "test_timeout", 0)
+
+    # Publishing properties
+    @property
+    def publish(self) -> t.Any | None:
+        return getattr(self.opts.publishing, "publish", None)
+
+    @property
+    def bump(self) -> t.Any | None:
+        return getattr(self.opts.publishing, "bump", None)
+
+    @property
+    def all(self) -> t.Any | None:
+        return getattr(self.opts.publishing, "all", None)
+
+    @property
+    def no_git_tags(self) -> bool:
+        return getattr(self.opts.publishing, "no_git_tags", False)
+
+    @property
+    def skip_version_check(self) -> bool:
+        return getattr(self.opts.publishing, "skip_version_check", False)
+
+    # AI properties
+    @property
+    def ai_agent(self) -> bool:
+        return getattr(self.opts.ai, "ai_agent", False)
+
+    @property
+    def start_mcp_server(self) -> bool:
+        return getattr(self.opts.ai, "start_mcp_server", False)
+
+    # Hook properties
+    @property
+    def skip_hooks(self) -> bool:
+        return getattr(self.opts.hooks, "skip_hooks", False)
+
+    @property
+    def update_precommit(self) -> bool:
+        return getattr(self.opts.hooks, "update_precommit", False)
+
+    @property
+    def experimental_hooks(self) -> bool:
+        return getattr(self.opts.hooks, "experimental_hooks", False)
+
+    @property
+    def enable_pyrefly(self) -> bool:
+        return getattr(self.opts.hooks, "enable_pyrefly", False)
+
+    @property
+    def enable_ty(self) -> bool:
+        return getattr(self.opts.hooks, "enable_ty", False)
+
+    # Cleaning properties
+    @property
+    def clean(self) -> bool:
+        return getattr(self.opts.cleaning, "clean", False)
+
+    # Progress properties
+    @property
+    def track_progress(self) -> bool:
+        return getattr(self.opts.progress, "track_progress", False)
+
+    # Default/static properties
+    @property
+    def cleanup(self) -> t.Any | None:
+        return None
+
+    @property
+    def cleanup_pypi(self) -> bool:
+        return False
+
+    @property
+    def coverage(self) -> bool:
+        return False
+
+    @property
+    def keep_releases(self) -> int:
+        return 10
+
+    @property
+    def fast(self) -> bool:
+        return False
+
+
+def _execute_init_stage(orchestrator: "WorkflowOrchestrator") -> bool:
     try:
         from pathlib import Path
 
@@ -186,9 +326,10 @@ def _execute_init_stage(orchestrator) -> bool:
 
         init_service = InitializationService(console, filesystem, git_service, pkg_path)
 
-        results = init_service.initialize_project(target_path=Path.cwd())
+        results = init_service.initialize_project_full(target_path=Path.cwd())
 
-        return results.get("success", False)
+        success_result: bool = bool(results.get("success", False))
+        return success_result
 
     except Exception as e:
         if hasattr(orchestrator, "console"):
@@ -197,7 +338,7 @@ def _execute_init_stage(orchestrator) -> bool:
 
 
 def register_core_tools(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def run_crackerjack_stage(args: str, kwargs: str) -> str:
         context = get_context()
         rate_limiter = context.rate_limiter if context else None
@@ -258,8 +399,8 @@ def _detect_errors_and_suggestions(
 ) -> tuple[list[str], list[str]]:
     import re
 
-    detected_errors = []
-    suggestions = []
+    detected_errors: list[str] = []
+    suggestions: list[str] = []
 
     for error_type, pattern in _get_error_patterns():
         if re.search(pattern, text, re.IGNORECASE):
@@ -271,7 +412,7 @@ def _detect_errors_and_suggestions(
 
 
 def register_analyze_errors_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def analyze_errors(output: str = "", include_suggestions: bool = True) -> str:
         context = get_context()
         if not context:

crackerjack/mcp/tools/error_analyzer.py

@@ -25,7 +25,8 @@ def _get_cached_patterns(context: t.Any, use_cache: bool) -> list[t.Any]:
     with suppress(Exception):
         cache = getattr(context, "cache", None)
         if cache and hasattr(cache, "get_error_patterns"):
-            return cache.get_error_patterns()
+            patterns: list[t.Any] = cache.get_error_patterns()
+            return patterns
 
     return []
 
@@ -70,7 +71,7 @@ def _build_error_analysis(patterns: list[t.Any], context: t.Any) -> dict[str, t.
 
 
 def _categorize_error_patterns(patterns: list[t.Any]) -> dict[str, list[t.Any]]:
-    categories = {
+    categories: dict[str, list[t.Any]] = {
         "syntax_errors": [],
         "import_errors": [],
         "type_errors": [],

crackerjack/mcp/tools/execution_tools.py

@@ -15,7 +15,7 @@ def register_execution_tools(mcp_app: t.Any) -> None:
 
 
 def _register_execute_crackerjack_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def execute_crackerjack(args: str, kwargs: str) -> str:
         context = get_context()
 
@@ -29,13 +29,11 @@ def _register_execute_crackerjack_tool(mcp_app: t.Any) -> None:
 
         extra_kwargs = kwargs_result["kwargs"]
 
-        # Add extended timeout for long-running operations
         if "execution_timeout" not in extra_kwargs:
-            # Default to 15 minutes, extend to 20 minutes for test operations
             if extra_kwargs.get("test", False) or extra_kwargs.get("testing", False):
-                extra_kwargs["execution_timeout"] = 1200  # 20 minutes for tests
+                extra_kwargs["execution_timeout"] = 1200
             else:
-                extra_kwargs["execution_timeout"] = 900  # 15 minutes default
+                extra_kwargs["execution_timeout"] = 900
 
         try:
             result = await execute_crackerjack_workflow(args, extra_kwargs)
@@ -53,7 +51,7 @@ def _register_execute_crackerjack_tool(mcp_app: t.Any) -> None:
 
 
 def _register_smart_error_analysis_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def smart_error_analysis(use_cache: bool = True) -> str:
         context = get_context()
 
@@ -71,7 +69,7 @@ def _register_smart_error_analysis_tool(mcp_app: t.Any) -> None:
 
 
 def _register_init_crackerjack_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     def init_crackerjack(args: str = "", kwargs: str = "{}") -> str:
         try:
             target_path, force, error = _parse_init_arguments(args, kwargs)
@@ -86,7 +84,7 @@ def _register_init_crackerjack_tool(mcp_app: t.Any) -> None:
 
 
 def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     def suggest_agents(
         task_description: str = "",
         project_type: str = "python",
@@ -139,7 +137,7 @@ def _parse_kwargs(kwargs: str) -> dict[str, t.Any]:
 def _parse_init_arguments(args: str, kwargs: str) -> tuple[t.Any, bool, str | None]:
     try:
         target_path = args.strip() or "."
-        kwargs_dict = json.loads(kwargs) if kwargs.strip() else {}
+        kwargs_dict: dict[str, t.Any] = json.loads(kwargs) if kwargs.strip() else {}
         force = kwargs_dict.get("force") or False
 
         from pathlib import Path
@@ -161,9 +159,14 @@ def _execute_initialization(target_path: t.Any, force: bool) -> dict[str, t.Any]
 
     console = Console()
 
-    return InitializationService(console, target_path).initialize_project(
-        force_update=force
-    )
+    from crackerjack.services.filesystem import FileSystemService
+    from crackerjack.services.git import GitService
+
+    filesystem = FileSystemService()
+    git_service = GitService(console)
+    return InitializationService(
+        console, filesystem, git_service, target_path
+    ).initialize_project_full(force=force)
 
 
 def _create_init_error_response(message: str) -> str: