crackerjack 0.29.0__py3-none-any.whl → 0.31.4__py3-none-any.whl

crackerjack/__main__.py

@@ -1,275 +1,247 @@
-import asyncio
-from enum import Enum
-
 import typer
-from pydantic import BaseModel, field_validator
 from rich.console import Console
 
-from .crackerjack import create_crackerjack_runner
+from .cli import (
+    CLI_OPTIONS,
+    BumpOption,
+    create_options,
+    handle_interactive_mode,
+    handle_standard_mode,
+    setup_ai_agent_env,
+)
+from .cli.handlers import (
+    handle_dashboard_mode,
+    handle_enhanced_monitor_mode,
+    handle_mcp_server,
+    handle_monitor_mode,
+    handle_restart_mcp_server,
+    handle_restart_websocket_server,
+    handle_start_websocket_server,
+    handle_stop_mcp_server,
+    handle_stop_websocket_server,
+    handle_watchdog_mode,
+)
 
 console = Console(force_terminal=True)
 app = typer.Typer(
-    help="Crackerjack: Your Python project setup and style enforcement tool."
+    help="Crackerjack: Your Python project setup and style enforcement tool.",
 )
 
 
-class BumpOption(str, Enum):
-    patch = "patch"
-    minor = "minor"
-    major = "major"
-
-    def __str__(self) -> str:
-        return self.value
-
-
-class Options(BaseModel):
-    commit: bool = False
-    interactive: bool = False
-    no_config_updates: bool = False
-    publish: BumpOption | None = None
-    bump: BumpOption | None = None
-    verbose: bool = False
-    update_precommit: bool = False
-    update_docs: bool = False
-    force_update_docs: bool = False
-    compress_docs: bool = False
-    clean: bool = False
-    test: bool = False
-    benchmark: bool = False
-    benchmark_regression: bool = False
-    benchmark_regression_threshold: float = 5.0
-    test_workers: int = 0
-    test_timeout: int = 0
-    all: BumpOption | None = None
-    ai_agent: bool = False
-    create_pr: bool = False
-    skip_hooks: bool = False
-    comprehensive: bool = False
-    async_mode: bool = False
-    track_progress: bool = False
-    resume_from: str | None = None
-    progress_file: str | None = None
-
-    @classmethod
-    @field_validator("publish", "bump", mode="before")
-    def validate_bump_options(cls, value: str | None) -> BumpOption | None:
-        if value is None:
-            return None
-        try:
-            return BumpOption(value.lower())
-        except ValueError:
-            valid_options = ", ".join([o.value for o in BumpOption])
-            raise ValueError(
-                f"Invalid bump option: {value}. Must be one of: {valid_options}"
-            )
-
-
-cli_options = {
-    "commit": typer.Option(False, "-c", "--commit", help="Commit changes to Git."),
-    "interactive": typer.Option(
-        False,
-        "-i",
-        "--interactive",
-        help="Use the interactive Rich UI for a better experience.",
-    ),
-    "no_config_updates": typer.Option(
-        False, "-n", "--no-config-updates", help="Do not update configuration files."
-    ),
-    "update_precommit": typer.Option(
-        False, "-u", "--update-precommit", help="Update pre-commit hooks."
-    ),
-    "update_docs": typer.Option(
-        False,
-        "--update-docs",
-        help="Update CLAUDE.md and RULES.md with latest quality standards.",
-    ),
-    "force_update_docs": typer.Option(
-        False,
-        "--force-update-docs",
-        help="Force update CLAUDE.md and RULES.md even if they exist.",
-    ),
-    "compress_docs": typer.Option(
-        False,
-        "--compress-docs",
-        help="Automatically compress CLAUDE.md to optimize for Claude Code (enabled by default for other projects).",
-    ),
-    "verbose": typer.Option(False, "-v", "--verbose", help="Enable verbose output."),
-    "publish": typer.Option(
-        None,
-        "-p",
-        "--publish",
-        help="Bump version and publish to PyPI (patch, minor, major).",
-        case_sensitive=False,
-    ),
-    "bump": typer.Option(
-        None,
-        "-b",
-        "--bump",
-        help="Bump version (patch, minor, major).",
-        case_sensitive=False,
-    ),
-    "clean": typer.Option(
-        False,
-        "-x",
-        "--clean",
-        help="Remove docstrings, line comments, and unnecessary whitespace from source code (doesn't affect test files).",
-    ),
-    "test": typer.Option(False, "-t", "--test", help="Run tests."),
-    "benchmark": typer.Option(
-        False,
-        "--benchmark",
-        help="Run tests in benchmark mode (disables parallel execution).",
-    ),
-    "benchmark_regression": typer.Option(
-        False,
-        "--benchmark-regression",
-        help="Fail tests if benchmarks regress beyond threshold.",
-    ),
-    "benchmark_regression_threshold": typer.Option(
-        5.0,
-        "--benchmark-regression-threshold",
-        help="Maximum allowed performance regression percentage (default: 5.0%).",
-    ),
-    "test_workers": typer.Option(
-        0,
-        "--test-workers",
-        help="Number of parallel workers for running tests (0 = auto-detect, 1 = disable parallelization).",
-    ),
-    "test_timeout": typer.Option(
-        0,
-        "--test-timeout",
-        help="Timeout in seconds for individual tests (0 = use default based on project size).",
-    ),
-    "skip_hooks": typer.Option(
-        False,
-        "-s",
-        "--skip-hooks",
-        help="Skip running pre-commit hooks (useful with -t).",
-    ),
-    "all": typer.Option(
-        None,
-        "-a",
-        "--all",
-        help="Run with `-x -t -p <patch|minor|major> -c` development options).",
-        case_sensitive=False,
-    ),
-    "create_pr": typer.Option(
-        False, "-r", "--pr", help="Create a pull request to the upstream repository."
-    ),
-    "ai_agent": typer.Option(
-        False,
-        "--ai-agent",
-        help="Enable AI agent mode with structured output.",
-        hidden=True,
-    ),
-    "comprehensive": typer.Option(
-        False,
-        "--comprehensive",
-        help="Use comprehensive pre-commit hooks (slower but thorough).",
-    ),
-    "async_mode": typer.Option(
-        False,
-        "--async",
-        help="Enable async mode for faster file operations (experimental).",
-        hidden=True,
-    ),
-    "track_progress": typer.Option(
-        False,
-        "--track-progress",
-        help="Enable session progress tracking with detailed markdown output.",
-    ),
-    "resume_from": typer.Option(
-        None,
-        "--resume-from",
-        help="Resume session from existing progress file.",
-    ),
-    "progress_file": typer.Option(
-        None,
-        "--progress-file",
-        help="Custom path for progress file (default: SESSION-PROGRESS-{timestamp}.md).",
-    ),
-}
+def _handle_monitoring_commands(
+    monitor: bool,
+    enhanced_monitor: bool,
+    dashboard: bool,
+    watchdog: bool,
+    dev: bool,
+) -> bool:
+    """Handle monitoring commands."""
+    if monitor:
+        handle_monitor_mode(dev_mode=dev)
+        return True
+    if enhanced_monitor:
+        handle_enhanced_monitor_mode(dev_mode=dev)
+        return True
+    if dashboard:
+        handle_dashboard_mode(dev_mode=dev)
+        return True
+    if watchdog:
+        handle_watchdog_mode()
+        return True
+    return False
+
+
+def _handle_websocket_commands(
+    start_websocket_server: bool,
+    stop_websocket_server: bool,
+    restart_websocket_server: bool,
+    websocket_port: int | None,
+) -> bool:
+    """Handle WebSocket server commands."""
+    if start_websocket_server:
+        port = websocket_port or 8675
+        handle_start_websocket_server(port)
+        return True
+    if stop_websocket_server:
+        handle_stop_websocket_server()
+        return True
+    if restart_websocket_server:
+        port = websocket_port or 8675
+        handle_restart_websocket_server(port)
+        return True
+    return False
+
+
+def _handle_mcp_commands(
+    start_mcp_server: bool,
+    stop_mcp_server: bool,
+    restart_mcp_server: bool,
+    websocket_port: int | None,
+) -> bool:
+    """Handle MCP server commands."""
+    if start_mcp_server:
+        handle_mcp_server(websocket_port)
+        return True
+    if stop_mcp_server:
+        handle_stop_mcp_server()
+        return True
+    if restart_mcp_server:
+        handle_restart_mcp_server(websocket_port)
+        return True
+    return False
+
+
+def _handle_server_commands(
+    monitor: bool,
+    enhanced_monitor: bool,
+    dashboard: bool,
+    watchdog: bool,
+    start_websocket_server: bool,
+    stop_websocket_server: bool,
+    restart_websocket_server: bool,
+    start_mcp_server: bool,
+    stop_mcp_server: bool,
+    restart_mcp_server: bool,
+    websocket_port: int | None,
+    dev: bool,
+) -> bool:
+    """Handle server-related commands. Returns True if a server command was handled."""
+    return (
+        _handle_monitoring_commands(monitor, enhanced_monitor, dashboard, watchdog, dev)
+        or _handle_websocket_commands(
+            start_websocket_server,
+            stop_websocket_server,
+            restart_websocket_server,
+            websocket_port,
+        )
+        or _handle_mcp_commands(
+            start_mcp_server,
+            stop_mcp_server,
+            restart_mcp_server,
+            websocket_port,
+        )
+    )
 
 
 @app.command()
 def main(
-    commit: bool = cli_options["commit"],
-    interactive: bool = cli_options["interactive"],
-    no_config_updates: bool = cli_options["no_config_updates"],
-    update_precommit: bool = cli_options["update_precommit"],
-    update_docs: bool = cli_options["update_docs"],
-    force_update_docs: bool = cli_options["force_update_docs"],
-    compress_docs: bool = cli_options["compress_docs"],
-    verbose: bool = cli_options["verbose"],
-    publish: BumpOption | None = cli_options["publish"],
-    all: BumpOption | None = cli_options["all"],
-    bump: BumpOption | None = cli_options["bump"],
-    clean: bool = cli_options["clean"],
-    test: bool = cli_options["test"],
-    benchmark: bool = cli_options["benchmark"],
-    benchmark_regression: bool = cli_options["benchmark_regression"],
-    benchmark_regression_threshold: float = cli_options[
-        "benchmark_regression_threshold"
-    ],
-    test_workers: int = cli_options["test_workers"],
-    test_timeout: int = cli_options["test_timeout"],
-    skip_hooks: bool = cli_options["skip_hooks"],
-    create_pr: bool = cli_options["create_pr"],
-    ai_agent: bool = cli_options["ai_agent"],
-    comprehensive: bool = cli_options["comprehensive"],
-    async_mode: bool = cli_options["async_mode"],
-    track_progress: bool = cli_options["track_progress"],
-    resume_from: str | None = cli_options["resume_from"],
-    progress_file: str | None = cli_options["progress_file"],
+    commit: bool = CLI_OPTIONS["commit"],
+    interactive: bool = CLI_OPTIONS["interactive"],
+    no_config_updates: bool = CLI_OPTIONS["no_config_updates"],
+    update_precommit: bool = CLI_OPTIONS["update_precommit"],
+    verbose: bool = CLI_OPTIONS["verbose"],
+    publish: BumpOption | None = CLI_OPTIONS["publish"],
+    all: BumpOption | None = CLI_OPTIONS["all"],
+    bump: BumpOption | None = CLI_OPTIONS["bump"],
+    clean: bool = CLI_OPTIONS["clean"],
+    test: bool = CLI_OPTIONS["test"],
+    benchmark: bool = CLI_OPTIONS["benchmark"],
+    test_workers: int = CLI_OPTIONS["test_workers"],
+    test_timeout: int = CLI_OPTIONS["test_timeout"],
+    skip_hooks: bool = CLI_OPTIONS["skip_hooks"],
+    fast: bool = CLI_OPTIONS["fast"],
+    comp: bool = CLI_OPTIONS["comp"],
+    create_pr: bool = CLI_OPTIONS["create_pr"],
+    ai_agent: bool = CLI_OPTIONS["ai_agent"],
+    start_mcp_server: bool = CLI_OPTIONS["start_mcp_server"],
+    stop_mcp_server: bool = CLI_OPTIONS["stop_mcp_server"],
+    restart_mcp_server: bool = CLI_OPTIONS["restart_mcp_server"],
+    async_mode: bool = CLI_OPTIONS["async_mode"],
+    experimental_hooks: bool = CLI_OPTIONS["experimental_hooks"],
+    enable_pyrefly: bool = CLI_OPTIONS["enable_pyrefly"],
+    enable_ty: bool = CLI_OPTIONS["enable_ty"],
+    no_git_tags: bool = CLI_OPTIONS["no_git_tags"],
+    skip_version_check: bool = CLI_OPTIONS["skip_version_check"],
+    start_websocket_server: bool = CLI_OPTIONS["start_websocket_server"],
+    stop_websocket_server: bool = CLI_OPTIONS["stop_websocket_server"],
+    restart_websocket_server: bool = CLI_OPTIONS["restart_websocket_server"],
+    websocket_port: int | None = CLI_OPTIONS["websocket_port"],
+    watchdog: bool = CLI_OPTIONS["watchdog"],
+    monitor: bool = CLI_OPTIONS["monitor"],
+    enhanced_monitor: bool = CLI_OPTIONS["enhanced_monitor"],
+    ai_debug: bool = CLI_OPTIONS["ai_debug"],
+    job_id: str | None = CLI_OPTIONS["job_id"],
+    orchestrated: bool = CLI_OPTIONS["orchestrated"],
+    orchestration_strategy: str = CLI_OPTIONS["orchestration_strategy"],
+    orchestration_progress: str = CLI_OPTIONS["orchestration_progress"],
+    orchestration_ai_mode: str = CLI_OPTIONS["orchestration_ai_mode"],
+    dev: bool = CLI_OPTIONS["dev"],
+    dashboard: bool = CLI_OPTIONS["dashboard"],
+    max_iterations: int = CLI_OPTIONS["max_iterations"],
+    coverage_status: bool = CLI_OPTIONS["coverage_status"],
+    coverage_goal: float | None = CLI_OPTIONS["coverage_goal"],
+    no_coverage_ratchet: bool = CLI_OPTIONS["no_coverage_ratchet"],
 ) -> None:
-    options = Options(
-        commit=commit,
-        interactive=interactive,
-        no_config_updates=no_config_updates,
-        update_precommit=update_precommit,
-        update_docs=update_docs,
-        force_update_docs=force_update_docs,
-        compress_docs=compress_docs,
-        verbose=verbose,
-        publish=publish,
-        bump=bump,
-        clean=clean,
-        test=test,
-        benchmark=benchmark,
-        benchmark_regression=benchmark_regression,
-        benchmark_regression_threshold=benchmark_regression_threshold,
-        test_workers=test_workers,
-        test_timeout=test_timeout,
-        skip_hooks=skip_hooks,
-        all=all,
-        ai_agent=ai_agent,
-        comprehensive=comprehensive,
-        create_pr=create_pr,
-        async_mode=async_mode,
-        track_progress=track_progress,
-        resume_from=resume_from,
-        progress_file=progress_file,
+    options = create_options(
+        commit,
+        interactive,
+        no_config_updates,
+        update_precommit,
+        verbose,
+        publish,
+        all,
+        bump,
+        clean,
+        test,
+        benchmark,
+        test_workers,
+        test_timeout,
+        skip_hooks,
+        fast,
+        comp,
+        create_pr,
+        ai_agent,
+        async_mode,
+        experimental_hooks,
+        enable_pyrefly,
+        enable_ty,
+        no_git_tags,
+        skip_version_check,
+        orchestrated,
+        orchestration_strategy,
+        orchestration_progress,
+        orchestration_ai_mode,
+        dev,
+        dashboard,
+        max_iterations,
+        coverage_status,
+        coverage_goal,
+        no_coverage_ratchet,
     )
-    if ai_agent:
-        import os
 
-        os.environ["AI_AGENT"] = "1"
+    if ai_debug:
+        ai_agent = True
+        verbose = True
+
+    setup_ai_agent_env(ai_agent, verbose or ai_debug)
+
+    # Handle server commands
+    if _handle_server_commands(
+        monitor,
+        enhanced_monitor,
+        dashboard,
+        watchdog,
+        start_websocket_server,
+        stop_websocket_server,
+        restart_websocket_server,
+        start_mcp_server,
+        stop_mcp_server,
+        restart_mcp_server,
+        websocket_port,
+        dev,
+    ):
+        return
+
+    # Handle main workflow
     if interactive:
-        from .interactive import launch_interactive_cli
+        handle_interactive_mode(options)
+    else:
+        handle_standard_mode(options, async_mode, job_id, orchestrated)
 
-        try:
-            from importlib.metadata import version
 
-            pkg_version = version("crackerjack")
-        except (ImportError, ModuleNotFoundError):
-            pkg_version = "0.19.8"
-        launch_interactive_cli(pkg_version)
-    else:
-        runner = create_crackerjack_runner(console=console)
-        if async_mode:
-            asyncio.run(runner.process_async(options))
-        else:
-            runner.process(options)
+def cli() -> None:
+    """Entry point for console script."""
+    app()
 
 
 if __name__ == "__main__":

crackerjack/agents/__init__.py

@@ -0,0 +1,41 @@
+# Import all agent modules to trigger registration
+from . import (
+    architect_agent,
+    documentation_agent,
+    dry_agent,
+    formatting_agent,
+    import_optimization_agent,
+    performance_agent,
+    refactoring_agent,
+    security_agent,
+    test_creation_agent,
+    test_specialist_agent,
+)
+from .base import AgentContext, FixResult, Issue, IssueType, Priority, SubAgent
+from .coordinator import AgentCoordinator
+from .tracker import AgentTracker, get_agent_tracker, reset_agent_tracker
+
+__all__ = [
+    "AgentContext",
+    "AgentCoordinator",
+    "AgentTracker",
+    "FixResult",
+    # Exported classes
+    "Issue",
+    "IssueType",
+    "Priority",
+    "SubAgent",
+    # Agent modules (imported for registration)
+    "architect_agent",
+    "documentation_agent",
+    "dry_agent",
+    "formatting_agent",
+    "get_agent_tracker",
+    "import_optimization_agent",
+    "performance_agent",
+    "refactoring_agent",
+    "reset_agent_tracker",
+    "security_agent",
+    "test_creation_agent",
+    "test_specialist_agent",
+]