crackerjack 0.31.18__py3-none-any.whl → 0.33.0__py3-none-any.whl

crackerjack/dynamic_config.py

@@ -5,30 +5,6 @@ from pathlib import Path
 import jinja2
 
 
-def _get_project_root() -> Path:
-    """Get the absolute path to the crackerjack project root."""
-    # Start from this file and go up to find the real project root
-    current_path = Path(__file__).resolve()
-    for parent in current_path.parents:
-        if (parent / "pyproject.toml").exists() and (parent / "tools").exists():
-            # Verify it's the crackerjack project by checking for unique markers and tools dir
-            try:
-                pyproject_content = (parent / "pyproject.toml").read_text()
-                if (
-                    'name = "crackerjack"' in pyproject_content
-                    and (
-                        parent / "tools" / "validate_regex_patterns_standalone.py"
-                    ).exists()
-                ):
-                    return parent
-            except Exception:
-                # If we can't read the file, continue searching
-                continue
-
-    # Fallback to the parent of the crackerjack package directory
-    return Path(__file__).resolve().parent.parent
-
-
 class HookMetadata(t.TypedDict):
     id: str
     name: str | None
@@ -70,7 +46,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "additional_dependencies": None,
             "types_or": None,
             "language": "system",
-            "entry": f"uv run python {_get_project_root() / 'tools' / 'validate_regex_patterns_standalone.py'}",
+            "entry": "uv run python -m crackerjack.tools.validate_regex_patterns",
             "experimental": False,
         },
         {

crackerjack/managers/publish_manager.py

@@ -5,17 +5,34 @@ from pathlib import Path
 
 from rich.console import Console
 
-from crackerjack.services.filesystem import FileSystemService
-from crackerjack.services.security import SecurityService
+from crackerjack.models.protocols import FileSystemInterface, SecurityServiceProtocol
 
 
 class PublishManagerImpl:
-    def __init__(self, console: Console, pkg_path: Path, dry_run: bool = False) -> None:
+    def __init__(
+        self,
+        console: Console,
+        pkg_path: Path,
+        dry_run: bool = False,
+        filesystem: FileSystemInterface | None = None,
+        security: SecurityServiceProtocol | None = None,
+    ) -> None:
         self.console = console
         self.pkg_path = pkg_path
         self.dry_run = dry_run
-        self.filesystem = FileSystemService()
-        self.security = SecurityService()
+
+        if filesystem is None:
+            from crackerjack.services.filesystem import FileSystemService
+
+            filesystem = FileSystemService()
+
+        if security is None:
+            from crackerjack.services.security import SecurityService
+
+            security = SecurityService()
+
+        self.filesystem = filesystem
+        self.security = security
 
     def _run_command(
         self,

crackerjack/managers/test_command_builder.py

@@ -8,7 +8,7 @@ class TestCommandBuilder:
         self.pkg_path = pkg_path
 
     def build_command(self, options: OptionsProtocol) -> list[str]:
-        cmd = ["python", "-m", "pytest"]
+        cmd = ["uv", "run", "python", "-m", "pytest"]
 
         self._add_coverage_options(cmd, options)
         self._add_worker_options(cmd, options)
@@ -23,17 +23,21 @@ class TestCommandBuilder:
         if hasattr(options, "test_workers") and options.test_workers:
             return options.test_workers
 
-        import multiprocessing
-
-        cpu_count = multiprocessing.cpu_count()
-
-        if cpu_count <= 2:
-            return 1
-        elif cpu_count <= 4:
-            return 2
-        elif cpu_count <= 8:
-            return 3
-        return 4
+        # Temporarily disable multi-worker execution due to pytest-xdist
+        # hanging issues with async tests. See GitHub issue for details.
+        # TODO: Re-enable after fixing async test timeout issues
+        return 1
+
+        # Original multi-worker logic (commented out):
+        # import multiprocessing
+        # cpu_count = multiprocessing.cpu_count()
+        # if cpu_count <= 2:
+        #     return 1
+        # elif cpu_count <= 4:
+        #     return 2
+        # elif cpu_count <= 8:
+        #     return 3
+        # return 4
 
     def get_test_timeout(self, options: OptionsProtocol) -> int:
         if hasattr(options, "test_timeout") and options.test_timeout:
@@ -95,7 +99,7 @@ class TestCommandBuilder:
         cmd.append(str(self.pkg_path))
 
     def build_specific_test_command(self, test_pattern: str) -> list[str]:
-        cmd = ["python", "-m", "pytest", "-v"]
+        cmd = ["uv", "run", "python", "-m", "pytest", "-v"]
 
         cmd.extend(
             [
@@ -112,6 +116,8 @@ class TestCommandBuilder:
 
     def build_validation_command(self) -> list[str]:
         return [
+            "uv",
+            "run",
             "python",
             "-m",
             "pytest",

crackerjack/managers/test_manager.py

@@ -5,21 +5,32 @@ from pathlib import Path
 
 from rich.console import Console
 
-from crackerjack.models.protocols import OptionsProtocol
-from crackerjack.services.coverage_ratchet import CoverageRatchetService
+from crackerjack.models.protocols import CoverageRatchetProtocol, OptionsProtocol
 
 from .test_command_builder import TestCommandBuilder
 from .test_executor import TestExecutor
 
 
 class TestManager:
-    def __init__(self, console: Console, pkg_path: Path) -> None:
+    def __init__(
+        self,
+        console: Console,
+        pkg_path: Path,
+        coverage_ratchet: CoverageRatchetProtocol | None = None,
+    ) -> None:
         self.console = console
         self.pkg_path = pkg_path
 
         self.executor = TestExecutor(console, pkg_path)
         self.command_builder = TestCommandBuilder(pkg_path)
-        self.coverage_ratchet = CoverageRatchetService(pkg_path, console)
+
+        if coverage_ratchet is None:
+            # Import here to avoid circular imports
+            from crackerjack.services.coverage_ratchet import CoverageRatchetService
+
+            coverage_ratchet = CoverageRatchetService(pkg_path, console)
+
+        self.coverage_ratchet = coverage_ratchet
 
         self._last_test_failures: list[str] = []
         self._progress_callback: t.Callable[[dict[str, t.Any]], None] | None = None

crackerjack/mcp/server_core.py

@@ -7,7 +7,12 @@ from typing import Final
 from rich.console import Console
 
 try:
-    from mcp.server.fastmcp import FastMCP
+    import tomli
+except ImportError:
+    tomli = None
+
+try:
+    from fastmcp import FastMCP
 
     _mcp_available = True
 except ImportError:
@@ -37,6 +42,42 @@ from .tools import (
 console = Console()
 
 
+def _load_mcp_config(project_path: Path) -> dict[str, t.Any]:
+    """Load MCP server configuration from pyproject.toml."""
+    pyproject_path = project_path / "pyproject.toml"
+
+    if not pyproject_path.exists() or not tomli:
+        return {
+            "http_port": 8676,
+            "http_host": "127.0.0.1",
+            "websocket_port": 8675,
+            "http_enabled": False,
+        }
+
+    try:
+        with pyproject_path.open("rb") as f:
+            pyproject_data = tomli.load(f)
+
+        crackerjack_config = pyproject_data.get("tool", {}).get("crackerjack", {})
+
+        return {
+            "http_port": crackerjack_config.get("mcp_http_port", 8676),
+            "http_host": crackerjack_config.get("mcp_http_host", "127.0.0.1"),
+            "websocket_port": crackerjack_config.get("mcp_websocket_port", 8675),
+            "http_enabled": crackerjack_config.get("mcp_http_enabled", False),
+        }
+    except Exception as e:
+        console.print(
+            f"[yellow]Warning: Failed to load MCP config from pyproject.toml: {e}[/yellow]"
+        )
+        return {
+            "http_port": 8676,
+            "http_host": "127.0.0.1",
+            "websocket_port": 8675,
+            "http_enabled": False,
+        }
+
+
 class MCPOptions:
     def __init__(self, **kwargs: t.Any) -> None:
         self.commit: bool = False
@@ -77,11 +118,14 @@ async def _start_websocket_server() -> bool:
     return False
 
 
-def create_mcp_server() -> t.Any | None:
+def create_mcp_server(config: dict[str, t.Any] | None = None) -> t.Any | None:
     if not MCP_AVAILABLE or FastMCP is None:
         return None
 
-    mcp_app = FastMCP("crackerjack - mcp-server")
+    if config is None:
+        config = {"http_port": 8676, "http_host": "127.0.0.1"}
+
+    mcp_app = FastMCP("crackerjack-mcp-server", streamable_http_path="/mcp")
 
     from crackerjack.slash_commands import get_slash_command_path
 
@@ -128,6 +172,8 @@ def handle_mcp_server_command(
     stop: bool = False,
     restart: bool = False,
     websocket_port: int | None = None,
+    http_mode: bool = False,
+    http_port: int | None = None,
 ) -> None:
     if stop or restart:
         console.print("[yellow]Stopping MCP servers...[/ yellow]")
@@ -157,7 +203,7 @@ def handle_mcp_server_command(
     if start or restart:
         console.print("[green]Starting MCP server...[/ green]")
         try:
-            main(".", websocket_port)
+            main(".", websocket_port, http_mode, http_port)
         except Exception as e:
             console.print(f"[red]Failed to start MCP server: {e}[/ red]")
 
@@ -177,45 +223,111 @@ def _stop_websocket_server() -> None:
             pass
 
 
-def main(project_path_arg: str = ".", websocket_port: int | None = None) -> None:
+def _merge_config_with_args(
+    mcp_config: dict[str, t.Any],
+    http_port: int | None,
+    http_mode: bool,
+) -> dict[str, t.Any]:
+    """Merge MCP configuration with command line arguments."""
+    if http_port:
+        mcp_config["http_port"] = http_port
+    if http_mode:
+        mcp_config["http_enabled"] = True
+    return mcp_config
+
+
+def _setup_server_context(
+    project_path: Path,
+    websocket_port: int | None,
+) -> MCPServerContext:
+    """Set up and initialize the MCP server context."""
+    config = MCPServerConfig(
+        project_path=project_path,
+        rate_limit_config=RateLimitConfig(),
+    )
+
+    context = MCPServerContext(config)
+    context.console = console
+
+    if websocket_port:
+        context.websocket_server_port = websocket_port
+
+    _initialize_context(context)
+    return context
+
+
+def _print_server_info(
+    project_path: Path,
+    mcp_config: dict[str, t.Any],
+    websocket_port: int | None,
+    http_mode: bool,
+) -> None:
+    """Print server startup information."""
+    console.print("[green]Starting Crackerjack MCP Server...[/ green]")
+    console.print(f"Project path: {project_path}")
+
+    if mcp_config.get("http_enabled", False) or http_mode:
+        console.print(
+            f"[cyan]HTTP Mode: http://{mcp_config['http_host']}:{mcp_config['http_port']}/mcp[/ cyan]"
+        )
+    else:
+        console.print("[cyan]STDIO Mode[/ cyan]")
+
+    if websocket_port:
+        console.print(f"WebSocket port: {websocket_port}")
+
+
+def _run_mcp_server(
+    mcp_app: t.Any, mcp_config: dict[str, t.Any], http_mode: bool
+) -> None:
+    """Execute the MCP server with appropriate transport mode."""
+    console.print("[yellow]MCP app created, about to run...[/ yellow]")
+
+    try:
+        if mcp_config.get("http_enabled", False) or http_mode:
+            host = mcp_config.get("http_host", "127.0.0.1")
+            port = mcp_config.get("http_port", 8676)
+            mcp_app.run(transport="streamable-http", host=host, port=port)
+        else:
+            mcp_app.run()
+    except Exception as e:
+        console.print(f"[red]MCP run failed: {e}[/ red]")
+        import traceback
+
+        traceback.print_exc()
+        raise
+
+
+def main(
+    project_path_arg: str = ".",
+    websocket_port: int | None = None,
+    http_mode: bool = False,
+    http_port: int | None = None,
+) -> None:
     if not MCP_AVAILABLE:
         return
 
     try:
         project_path = Path(project_path_arg).resolve()
 
-        config = MCPServerConfig(
-            project_path=project_path,
-            rate_limit_config=RateLimitConfig(),
-        )
-
-        context = MCPServerContext(config)
-        context.console = console
+        # Load and merge configuration
+        mcp_config = _load_mcp_config(project_path)
+        mcp_config = _merge_config_with_args(mcp_config, http_port, http_mode)
 
-        if websocket_port:
-            context.websocket_server_port = websocket_port
+        # Set up server context
+        _setup_server_context(project_path, websocket_port)
 
-        _initialize_context(context)
-
-        mcp_app = create_mcp_server()
+        # Create MCP server
+        mcp_app = create_mcp_server(mcp_config)
         if not mcp_app:
             console.print("[red]Failed to create MCP server[/ red]")
             return
 
-        console.print("[green]Starting Crackerjack MCP Server...[/ green]")
-        console.print(f"Project path: {project_path}")
-        if websocket_port:
-            console.print(f"WebSocket port: {websocket_port}")
+        # Print server information
+        _print_server_info(project_path, mcp_config, websocket_port, http_mode)
 
-        console.print("[yellow]MCP app created, about to run...[/ yellow]")
-        try:
-            mcp_app.run()
-        except Exception as e:
-            console.print(f"[red]MCP run failed: {e}[/ red]")
-            import traceback
-
-            traceback.print_exc()
-            raise
+        # Run the server
+        _run_mcp_server(mcp_app, mcp_config, http_mode)
 
     except KeyboardInterrupt:
         console.print("Server stopped by user")
@@ -232,7 +344,23 @@ def main(project_path_arg: str = ".", websocket_port: int | None = None) -> None
 if __name__ == "__main__":
     import sys
 
-    project_path = sys.argv[1] if len(sys.argv) > 1 else "."
-    websocket_port = int(sys.argv[2]) if len(sys.argv) > 2 else None
-
-    main(project_path, websocket_port)
+    # Initialize defaults
+    project_path = "."
+    websocket_port = None
+    http_mode = "--http" in sys.argv
+    http_port = None
+
+    # Parse project path from non-flag arguments
+    non_flag_args = [arg for arg in sys.argv[1:] if not arg.startswith("--")]
+    if non_flag_args:
+        project_path = non_flag_args[0]
+        if len(non_flag_args) > 1 and non_flag_args[1].isdigit():
+            websocket_port = int(non_flag_args[1])
+
+    # Parse HTTP port flag
+    if "--http-port" in sys.argv:
+        port_idx = sys.argv.index("--http-port")
+        if port_idx + 1 < len(sys.argv):
+            http_port = int(sys.argv[port_idx + 1])
+
+    main(project_path, websocket_port, http_mode, http_port)

crackerjack/mcp/tools/core_tools.py

@@ -186,7 +186,7 @@ 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)
 

crackerjack/mcp/tools/execution_tools.py

@@ -29,6 +29,14 @@ 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
+            else:
+                extra_kwargs["execution_timeout"] = 900  # 15 minutes default
+
         try:
             result = await execute_crackerjack_workflow(args, extra_kwargs)
             return json.dumps(result, indent=2)
@@ -153,9 +161,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()
+    return InitializationService(
+        console, filesystem, git_service, target_path
+    ).initialize_project_full(force=force)
 
 
 def _create_init_error_response(message: str) -> str: