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

crackerjack/models/config_adapter.py

@@ -0,0 +1,230 @@
+"""Adapter for converting between the old OptionsProtocol and new WorkflowOptions.
+
+This provides backward compatibility during the migration period.
+"""
+
+import typing as t
+
+from .config import (
+    AIConfig,
+    CleaningConfig,
+    EnterpriseConfig,
+    ExecutionConfig,
+    GitConfig,
+    HookConfig,
+    ProgressConfig,
+    PublishConfig,
+    TestConfig,
+    WorkflowOptions,
+)
+from .protocols import OptionsProtocol
+
+
+class OptionsAdapter:
+    """Adapter to convert between old and new configuration formats."""
+
+    @staticmethod
+    def from_options_protocol(options: OptionsProtocol) -> WorkflowOptions:
+        """Convert OptionsProtocol to WorkflowOptions."""
+        return WorkflowOptions(
+            cleaning=CleaningConfig(
+                clean=getattr(options, "clean", True),
+                update_docs=getattr(options, "update_docs", False),
+                force_update_docs=getattr(options, "force_update_docs", False),
+                compress_docs=getattr(options, "compress_docs", False),
+                auto_compress_docs=getattr(options, "auto_compress_docs", False),
+            ),
+            hooks=HookConfig(
+                skip_hooks=getattr(options, "skip_hooks", False),
+                update_precommit=getattr(options, "update_precommit", False),
+                experimental_hooks=getattr(options, "experimental_hooks", False),
+                enable_pyrefly=getattr(options, "enable_pyrefly", False),
+                enable_ty=getattr(options, "enable_ty", False),
+            ),
+            testing=TestConfig(
+                test=getattr(options, "test", False),
+                benchmark=getattr(options, "benchmark", False),
+                test_workers=getattr(options, "test_workers", 0),
+                test_timeout=getattr(options, "test_timeout", 0),
+            ),
+            publishing=PublishConfig(
+                publish=getattr(options, "publish", None),
+                bump=getattr(options, "bump", None),
+                all=getattr(options, "all", None),
+                no_git_tags=getattr(options, "no_git_tags", False),
+                skip_version_check=getattr(options, "skip_version_check", False),
+            ),
+            git=GitConfig(
+                commit=getattr(options, "commit", False),
+                create_pr=getattr(options, "create_pr", False),
+            ),
+            ai=AIConfig(
+                ai_agent=getattr(options, "ai_agent", False),
+                autofix=getattr(options, "autofix", True),  # Default true per CLAUDE.md
+                ai_agent_autofix=getattr(options, "ai_agent_autofix", False),
+                start_mcp_server=getattr(options, "start_mcp_server", False),
+                max_iterations=getattr(options, "max_iterations", 10),
+            ),
+            execution=ExecutionConfig(
+                interactive=getattr(options, "interactive", False),
+                verbose=getattr(options, "verbose", False),
+                async_mode=getattr(options, "async_mode", False),
+                no_config_updates=getattr(options, "no_config_updates", False),
+            ),
+            progress=ProgressConfig(
+                enabled=getattr(options, "track_progress", False),
+            ),
+            enterprise=EnterpriseConfig(
+                enabled=getattr(options, "enterprise_batch", None) is not None,
+                license_key=getattr(options, "license_key", None),
+                organization=getattr(options, "organization", None),
+            ),
+        )
+
+    @staticmethod
+    def to_options_protocol(
+        workflow_options: WorkflowOptions,
+    ) -> "LegacyOptionsWrapper":
+        """Convert WorkflowOptions back to OptionsProtocol for backward compatibility."""
+        return LegacyOptionsWrapper(workflow_options)
+
+
+class LegacyOptionsWrapper:
+    """Wrapper that provides OptionsProtocol interface over WorkflowOptions."""
+
+    def __init__(self, workflow_options: WorkflowOptions) -> None:
+        self._options = workflow_options
+
+    # All the original OptionsProtocol attributes, delegating to the focused configs
+
+    @property
+    def commit(self) -> bool:
+        return self._options.git.commit
+
+    @property
+    def interactive(self) -> bool:
+        return self._options.execution.interactive
+
+    @property
+    def no_config_updates(self) -> bool:
+        return self._options.execution.no_config_updates
+
+    @property
+    def verbose(self) -> bool:
+        return self._options.execution.verbose
+
+    @property
+    def update_docs(self) -> bool:
+        return self._options.cleaning.update_docs
+
+    @property
+    def force_update_docs(self) -> bool:
+        return self._options.cleaning.force_update_docs
+
+    @property
+    def compress_docs(self) -> bool:
+        return self._options.cleaning.compress_docs
+
+    @property
+    def auto_compress_docs(self) -> bool:
+        return self._options.cleaning.auto_compress_docs
+
+    @property
+    def clean(self) -> bool:
+        return self._options.cleaning.clean
+
+    @property
+    def test(self) -> bool:
+        return self._options.testing.test
+
+    @property
+    def benchmark(self) -> bool:
+        return self._options.testing.benchmark
+
+    @property
+    def test_workers(self) -> int:
+        return self._options.testing.test_workers
+
+    @property
+    def test_timeout(self) -> int:
+        return self._options.testing.test_timeout
+
+    @property
+    def publish(self) -> t.Any | None:
+        return self._options.publishing.publish
+
+    @property
+    def bump(self) -> t.Any | None:
+        return self._options.publishing.bump
+
+    @property
+    def all(self) -> t.Any | None:
+        return self._options.publishing.all
+
+    @property
+    def ai_agent(self) -> bool:
+        return self._options.ai.ai_agent
+
+    @property
+    def autofix(self) -> bool:
+        return self._options.ai.autofix
+
+    @property
+    def ai_agent_autofix(self) -> bool:
+        return self._options.ai.ai_agent_autofix
+
+    @property
+    def start_mcp_server(self) -> bool:
+        return self._options.ai.start_mcp_server
+
+    @property
+    def max_iterations(self) -> int:
+        return self._options.ai.max_iterations
+
+    @property
+    def create_pr(self) -> bool:
+        return self._options.git.create_pr
+
+    @property
+    def skip_hooks(self) -> bool:
+        return self._options.hooks.skip_hooks
+
+    @property
+    def update_precommit(self) -> bool:
+        return self._options.hooks.update_precommit
+
+    @property
+    def async_mode(self) -> bool:
+        return self._options.execution.async_mode
+
+    @property
+    def track_progress(self) -> bool:
+        return self._options.progress.enabled
+
+    @property
+    def experimental_hooks(self) -> bool:
+        return self._options.hooks.experimental_hooks
+
+    @property
+    def enable_pyrefly(self) -> bool:
+        return self._options.hooks.enable_pyrefly
+
+    @property
+    def enable_ty(self) -> bool:
+        return self._options.hooks.enable_ty
+
+    @property
+    def no_git_tags(self) -> bool:
+        return self._options.publishing.no_git_tags
+
+    @property
+    def skip_version_check(self) -> bool:
+        return self._options.publishing.skip_version_check
+
+    @property
+    def enterprise_batch(self) -> str | None:
+        return None  # Deprecated field
+
+    @property
+    def monitor_dashboard(self) -> str | None:
+        return None  # Deprecated field

crackerjack/models/protocols.py

@@ -0,0 +1,118 @@
+import subprocess
+import typing as t
+
+
+@t.runtime_checkable
+class CommandRunner(t.Protocol):
+    def execute_command(
+        self,
+        cmd: list[str],
+        **kwargs: t.Any,
+    ) -> subprocess.CompletedProcess[str]: ...
+
+
+@t.runtime_checkable
+class OptionsProtocol(t.Protocol):
+    commit: bool
+    interactive: bool
+    no_config_updates: bool
+    verbose: bool
+    clean: bool
+    test: bool
+    benchmark: bool
+    test_workers: int = 0
+    test_timeout: int = 0
+    publish: t.Any | None
+    bump: t.Any | None
+    all: t.Any | None
+    ai_agent: bool = False
+    start_mcp_server: bool = False
+    create_pr: bool = False
+    skip_hooks: bool = False
+    update_precommit: bool = False
+    async_mode: bool = False
+    experimental_hooks: bool = False
+    enable_pyrefly: bool = False
+    enable_ty: bool = False
+    cleanup: t.Any | None = None
+    no_git_tags: bool = False
+    skip_version_check: bool = False
+    cleanup_pypi: bool = False
+    coverage: bool = False
+    keep_releases: int = 10
+    track_progress: bool = False
+    fast: bool = False
+    comp: bool = False
+    enterprise_batch: str | None = None
+    monitor_dashboard: str | None = None
+    coverage: bool = False
+
+
+@t.runtime_checkable
+class ConsoleInterface(t.Protocol):
+    def print(self, *args: t.Any, **kwargs: t.Any) -> None: ...
+
+    def input(self, _: str = "") -> str: ...
+
+
+@t.runtime_checkable
+class FileSystemInterface(t.Protocol):
+    def read_file(self, path: str | t.Any) -> str: ...
+
+    def write_file(self, path: str | t.Any, content: str) -> None: ...
+
+    def exists(self, path: str | t.Any) -> bool: ...
+
+    def mkdir(self, path: str | t.Any, parents: bool = False) -> None: ...
+
+
+@t.runtime_checkable
+class GitInterface(t.Protocol):
+    def is_git_repo(self) -> bool: ...
+
+    def get_changed_files(self) -> list[str]: ...
+
+    def commit(self, message: str) -> bool: ...
+
+    def push(self) -> bool: ...
+
+    def add_files(self, files: list[str]) -> bool: ...
+
+    def get_commit_message_suggestions(self, changed_files: list[str]) -> list[str]: ...
+
+
+@t.runtime_checkable
+class HookManager(t.Protocol):
+    def run_fast_hooks(self) -> list[t.Any]: ...
+
+    def run_comprehensive_hooks(self) -> list[t.Any]: ...
+
+    def install_hooks(self) -> bool: ...
+
+    def set_config_path(self, path: str | t.Any) -> None: ...
+
+    def get_hook_summary(self, results: t.Any) -> t.Any: ...
+
+
+@t.runtime_checkable
+class TestManagerProtocol(t.Protocol):
+    def run_tests(self, options: OptionsProtocol) -> bool: ...
+
+    def get_coverage(self) -> dict[str, t.Any]: ...
+
+    def validate_test_environment(self) -> bool: ...
+
+    def get_test_failures(self) -> list[str]: ...
+
+
+@t.runtime_checkable
+class PublishManager(t.Protocol):
+    def bump_version(self, version_type: str) -> str: ...
+
+    def publish_package(self) -> bool: ...
+
+    def validate_auth(self) -> bool: ...
+
+    def create_git_tag(self, version: str) -> bool: ...
+
+    def cleanup_old_releases(self, keep_releases: int) -> None: ...

crackerjack/models/task.py

@@ -0,0 +1,154 @@
+import time
+import typing as t
+from dataclasses import dataclass
+from enum import Enum
+
+from pydantic import BaseModel
+from rich.console import Console
+
+
+class TaskStatus(Enum):
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass
+class Task:
+    id: str
+    name: str
+    status: TaskStatus
+    details: str | None = None
+
+    def to_dict(self) -> dict[str, t.Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "status": self.status.value,
+            "details": self.details,
+        }
+
+
+@dataclass
+class HookResult:
+    id: str
+    name: str
+    status: str
+    duration: float
+    files_processed: int = 0
+    issues_found: list[str] | None = None
+    stage: str = "pre-commit"
+
+    def __post_init__(self) -> None:
+        if self.issues_found is None:
+            self.issues_found = []
+
+
+@dataclass
+class TaskStatusData:
+    id: str
+    name: str
+    status: str
+    start_time: float | None = None
+    end_time: float | None = None
+    duration: float | None = None
+    details: str | None = None
+    error_message: str | None = None
+    files_changed: list[str] | None = None
+
+    def __post_init__(self) -> None:
+        if self.files_changed is None:
+            self.files_changed = []
+        if self.start_time is not None and self.end_time is not None:
+            self.duration = self.end_time - self.start_time
+
+
+class SessionTracker(BaseModel, arbitrary_types_allowed=True):
+    console: Console
+    session_id: str
+    start_time: float
+    progress_file: t.Any = None
+    tasks: dict[str, TaskStatusData] = {}
+    current_task: str | None = None
+    metadata: dict[str, t.Any] = {}
+
+    def __init__(self, **data: t.Any) -> None:
+        super().__init__(**data)
+        if not self.tasks:
+            self.tasks = {}
+        if not self.metadata:
+            self.metadata = {}
+
+    def start_task(
+        self,
+        task_id: str,
+        task_name: str,
+        details: str | None = None,
+    ) -> None:
+        task = TaskStatusData(
+            id=task_id,
+            name=task_name,
+            status="in_progress",
+            start_time=time.time(),
+            details=details,
+        )
+        self.tasks[task_id] = task
+        self.current_task = task_id
+        self.console.print(f"[yellow]⏳[/yellow] Started: {task_name}")
+
+    def complete_task(
+        self,
+        task_id: str,
+        details: str | None = None,
+        files_changed: list[str] | None = None,
+    ) -> None:
+        if task_id in self.tasks:
+            task = self.tasks[task_id]
+            task.status = "completed"
+            task.end_time = time.time()
+            task.duration = task.end_time - (task.start_time or task.end_time)
+            if details:
+                task.details = details
+            if files_changed:
+                task.files_changed = files_changed
+                self.console.print(f"[green]✅[/green] Completed: {task.name}")
+            if self.current_task == task_id:
+                self.current_task = None
+
+    def fail_task(
+        self,
+        task_id: str,
+        error_message: str,
+        details: str | None = None,
+    ) -> None:
+        if task_id in self.tasks:
+            task = self.tasks[task_id]
+            task.status = "failed"
+            task.end_time = time.time()
+            task.duration = task.end_time - (task.start_time or task.end_time)
+            task.error_message = error_message
+            if details:
+                task.details = details
+                self.console.print(
+                    f"[red]❌[/red] Failed: {task.name} - {error_message}",
+                )
+            if self.current_task == task_id:
+                self.current_task = None
+
+    def get_summary(self) -> dict[str, t.Any]:
+        completed = sum(1 for task in self.tasks.values() if task.status == "completed")
+        failed = sum(1 for task in self.tasks.values() if task.status == "failed")
+        in_progress = sum(
+            1 for task in self.tasks.values() if task.status == "in_progress"
+        )
+
+        return {
+            "session_id": self.session_id,
+            "duration": time.time() - self.start_time,
+            "total_tasks": len(self.tasks),
+            "completed": completed,
+            "failed": failed,
+            "in_progress": in_progress,
+            "current_task": self.current_task,
+        }