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

crackerjack/models/pydantic_models.py

@@ -0,0 +1,320 @@
+"""Pydantic models to replace dataclasses in the Crackerjack codebase."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class CleaningConfig(BaseModel):
+    clean: bool = True
+    update_docs: bool = False
+    force_update_docs: bool = False
+    compress_docs: bool = False
+    auto_compress_docs: bool = False
+    targets: list[str] = Field(
+        default_factory=list
+    )  # Changed Path to str for validation
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "CleaningConfig":
+        return cls(
+            clean=getattr(settings, "clean", True),
+            update_docs=getattr(settings, "update_docs", False),
+            force_update_docs=getattr(settings, "force_update_docs", False),
+            compress_docs=getattr(settings, "compress_docs", False),
+            auto_compress_docs=getattr(settings, "auto_compress_docs", False),
+            targets=[str(p) for p in getattr(settings, "targets", [])],
+        )
+
+
+class HookConfig(BaseModel):
+    skip_hooks: bool = False
+    update_precommit: bool = False
+    experimental_hooks: bool = False
+    enable_pyrefly: bool = False
+    enable_ty: bool = False
+    enable_lsp_optimization: bool = False
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "HookConfig":
+        return cls(
+            skip_hooks=getattr(settings, "skip_hooks", False),
+            update_precommit=getattr(settings, "update_precommit", False),
+            experimental_hooks=getattr(settings, "experimental_hooks", False),
+            enable_pyrefly=getattr(settings, "enable_pyrefly", False),
+            enable_ty=getattr(settings, "enable_ty", False),
+            enable_lsp_optimization=getattr(settings, "enable_lsp_optimization", False),
+        )
+
+
+class TestConfig(BaseModel):
+    test: bool = False
+    benchmark: bool = False
+    benchmark_regression: bool = False
+    benchmark_regression_threshold: float = 0.1
+    test_workers: int = 0
+    test_timeout: int = 0
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "TestConfig":
+        return cls(
+            test=getattr(settings, "test", False),
+            benchmark=getattr(settings, "benchmark", False),
+            benchmark_regression=getattr(settings, "benchmark_regression", False),
+            benchmark_regression_threshold=getattr(
+                settings,
+                "benchmark_regression_threshold",
+                0.1,
+            ),
+            test_workers=getattr(settings, "test_workers", 0),
+            test_timeout=getattr(settings, "test_timeout", 0),
+        )
+
+
+class PublishConfig(BaseModel):
+    publish: str | None = None
+    bump: str | None = None
+    all: str | None = None
+    cleanup_pypi: bool = False
+    keep_releases: int = 10
+    no_git_tags: bool = False
+    skip_version_check: bool = False
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "PublishConfig":
+        return cls(
+            publish=getattr(settings, "publish", None),
+            bump=getattr(settings, "bump", None),
+            all=getattr(settings, "all", None),
+            cleanup_pypi=getattr(settings, "cleanup_pypi", False),
+            keep_releases=getattr(settings, "keep_releases", 10),
+            no_git_tags=getattr(settings, "no_git_tags", False),
+            skip_version_check=getattr(settings, "skip_version_check", False),
+        )
+
+
+class GitConfig(BaseModel):
+    commit: bool = False
+    create_pr: bool = False
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "GitConfig":
+        return cls(
+            commit=getattr(settings, "commit", False),
+            create_pr=getattr(settings, "create_pr", False),
+        )
+
+
+class AIConfig(BaseModel):
+    ai_agent: bool = False
+    autofix: bool = True
+    ai_agent_autofix: bool = False
+    start_mcp_server: bool = False
+    max_iterations: int = 5
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "AIConfig":
+        return cls(
+            ai_agent=getattr(settings, "ai_agent", False),
+            autofix=getattr(settings, "autofix", True),
+            ai_agent_autofix=getattr(settings, "ai_agent_autofix", False),
+            start_mcp_server=getattr(settings, "start_mcp_server", False),
+            max_iterations=getattr(settings, "max_iterations", 5),
+        )
+
+
+class ExecutionConfig(BaseModel):
+    interactive: bool = True
+    verbose: bool = False
+    async_mode: bool = False
+    no_config_updates: bool = False
+    dry_run: bool = False
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "ExecutionConfig":
+        return cls(
+            interactive=getattr(settings, "interactive", True),
+            verbose=getattr(settings, "verbose", False),
+            async_mode=getattr(settings, "async_mode", False),
+            no_config_updates=getattr(settings, "no_config_updates", False),
+            dry_run=getattr(settings, "dry_run", False),
+        )
+
+
+class ProgressConfig(BaseModel):
+    track_progress: bool = False
+    resume_from: str | None = None
+    progress_file: str | None = None
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "ProgressConfig":
+        return cls(
+            track_progress=getattr(settings, "enabled", False),
+            resume_from=getattr(settings, "resume_from", None),
+            progress_file=getattr(settings, "progress_file", None),
+        )
+
+
+class CleanupConfig(BaseModel):
+    auto_cleanup: bool = True
+    keep_debug_logs: int = 5
+    keep_coverage_files: int = 10
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "CleanupConfig":
+        return cls(
+            auto_cleanup=getattr(settings, "auto_cleanup", True),
+            keep_debug_logs=getattr(settings, "keep_debug_logs", 5),
+            keep_coverage_files=getattr(settings, "keep_coverage_files", 10),
+        )
+
+
+class AdvancedConfig(BaseModel):
+    enabled: bool = False
+    license_key: str | None = None
+    organization: str | None = None
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "AdvancedConfig":
+        return cls(
+            enabled=getattr(settings, "enabled", False),
+            license_key=getattr(settings, "license_key", None),
+            organization=getattr(settings, "organization", None),
+        )
+
+
+class MCPServerConfig(BaseModel):
+    http_port: int = 8676
+    http_host: str = "127.0.0.1"
+    websocket_port: int = 8675
+    http_enabled: bool = False
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "MCPServerConfig":
+        return cls(
+            http_port=getattr(settings, "http_port", 8676),
+            http_host=getattr(settings, "http_host", "127.0.0.1"),
+            websocket_port=getattr(settings, "websocket_port", 8675),
+            http_enabled=getattr(settings, "http_enabled", False),
+        )
+
+
+class ZubanLSPConfig(BaseModel):
+    enabled: bool = True
+    auto_start: bool = True
+    port: int = 8677
+    mode: str = "stdio"
+    timeout: int = 30
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "ZubanLSPConfig":
+        return cls(
+            enabled=getattr(settings, "enabled", True),
+            auto_start=getattr(settings, "auto_start", True),
+            port=getattr(settings, "port", 8677),
+            mode=getattr(settings, "mode", "stdio"),
+            timeout=getattr(settings, "timeout", 30),
+        )
+
+
+class WorkflowOptions(BaseModel):
+    cleaning: CleaningConfig = Field(default_factory=CleaningConfig)
+    hooks: HookConfig = Field(default_factory=HookConfig)
+    testing: TestConfig = Field(default_factory=TestConfig)
+    publishing: PublishConfig = Field(default_factory=PublishConfig)
+    git: GitConfig = Field(default_factory=GitConfig)
+    ai: AIConfig = Field(default_factory=AIConfig)
+    execution: ExecutionConfig = Field(default_factory=ExecutionConfig)
+    progress: ProgressConfig = Field(default_factory=ProgressConfig)
+    cleanup: CleanupConfig = Field(default_factory=CleanupConfig)
+    advanced: AdvancedConfig = Field(default_factory=AdvancedConfig)
+    mcp_server: MCPServerConfig = Field(default_factory=MCPServerConfig)
+    zuban_lsp: ZubanLSPConfig = Field(default_factory=ZubanLSPConfig)
+
+    # Simple properties that map to nested config values
+    @property
+    def clean(self) -> bool:
+        return self.cleaning.clean
+
+    @clean.setter
+    def clean(self, value: bool) -> None:
+        self.cleaning.clean = value
+
+    @property
+    def test(self) -> bool:
+        return self.testing.test
+
+    @test.setter
+    def test(self, value: bool) -> None:
+        self.testing.test = value
+
+    @property
+    def publish(self) -> str | None:
+        return self.publishing.publish
+
+    @publish.setter
+    def publish(self, value: str | None) -> None:
+        self.publishing.publish = value
+
+    @property
+    def commit(self) -> bool:
+        return self.git.commit
+
+    @commit.setter
+    def commit(self, value: bool) -> None:
+        self.git.commit = value
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "WorkflowOptions":
+        # Simplified implementation for demonstration
+        return cls(
+            cleaning=CleaningConfig.from_settings(getattr(settings, "cleaning", {})),
+            hooks=HookConfig.from_settings(getattr(settings, "hooks", {})),
+            testing=TestConfig.from_settings(getattr(settings, "testing", {})),
+            publishing=PublishConfig.from_settings(getattr(settings, "publishing", {})),
+            git=GitConfig.from_settings(getattr(settings, "git", {})),
+            ai=AIConfig.from_settings(getattr(settings, "ai", {})),
+            execution=ExecutionConfig.from_settings(getattr(settings, "execution", {})),
+            progress=ProgressConfig.from_settings(getattr(settings, "progress", {})),
+            cleanup=CleanupConfig.from_settings(getattr(settings, "cleanup", {})),
+            advanced=AdvancedConfig.from_settings(getattr(settings, "advanced", {})),
+            mcp_server=MCPServerConfig.from_settings(
+                getattr(settings, "mcp_server", {})
+            ),
+            zuban_lsp=ZubanLSPConfig.from_settings(getattr(settings, "zuban_lsp", {})),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump()
+
+
+# Results models
+class ExecutionResult(BaseModel):
+    operation_id: str
+    success: bool
+    duration_seconds: float
+    output: str = ""
+    error: str = ""
+    exit_code: int = 0
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class ParallelExecutionResult(BaseModel):
+    group_name: str
+    total_operations: int
+    successful_operations: int
+    failed_operations: int
+    total_duration_seconds: float
+    results: list[ExecutionResult]
+
+    @property
+    def success_rate(self) -> float:
+        return (
+            self.successful_operations / self.total_operations
+            if self.total_operations > 0
+            else 0.0
+        )
+
+    @property
+    def overall_success(self) -> bool:
+        return self.failed_operations == 0

crackerjack/models/qa_config.py

@@ -0,0 +1,145 @@
+"""Configuration models for ACB Quality Assurance framework."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from crackerjack.models.qa_results import QACheckType
+
+
+class QACheckConfig(BaseModel):
+    """Configuration for a single quality assurance check.
+
+    This model defines how a QA check should be executed, including
+    file patterns, exclusions, timeouts, and check-specific settings.
+    """
+
+    check_id: UUID = Field(
+        ...,
+        description="Unique identifier for this check",
+    )
+    check_name: str = Field(
+        ...,
+        description="Human-readable name (e.g., 'ruff-format', 'pyright')",
+    )
+    check_type: QACheckType = Field(
+        ...,
+        description="Category of the check (lint, format, type_check, etc.)",
+    )
+    enabled: bool = Field(
+        default=True,
+        description="Whether this check is enabled",
+    )
+    file_patterns: list[str] = Field(
+        default_factory=list,
+        description="Glob patterns for files to check",
+    )
+    exclude_patterns: list[str] = Field(
+        default_factory=list,
+        description="Glob patterns for files to exclude",
+    )
+    timeout_seconds: int = Field(
+        default=300,  # 5 minutes default
+        gt=0,  # Must be positive
+        description="Maximum execution time in seconds",
+    )
+    retry_on_failure: bool = Field(
+        default=False,
+        description="Whether to retry if the check fails",
+    )
+    is_formatter: bool = Field(
+        default=False,
+        description="Whether this check modifies files",
+    )
+    parallel_safe: bool = Field(
+        default=True,
+        description="Whether this check can run in parallel with others",
+    )
+    stage: str = Field(
+        default="fast",
+        description="Execution stage: 'fast' or 'comprehensive'",
+    )
+    settings: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Check-specific configuration settings",
+    )
+
+    @property
+    def is_fast_stage(self) -> bool:
+        """Check if this is a fast stage check."""
+        return self.stage == "fast"
+
+    @property
+    def is_comprehensive_stage(self) -> bool:
+        """Check if this is a comprehensive stage check."""
+        return self.stage == "comprehensive"
+
+
+class QAOrchestratorConfig(BaseModel):
+    """Configuration for the quality assurance orchestrator.
+
+    This model defines global settings for QA execution, including
+    parallelization, caching, and execution order.
+    """
+
+    project_root: Path = Field(
+        ...,
+        description="Root directory of the project being checked",
+    )
+    max_parallel_checks: int = Field(
+        default=4,
+        gt=0,  # Must be positive
+        description="Maximum number of checks to run in parallel",
+    )
+    enable_caching: bool = Field(
+        default=True,
+        description="Whether to cache check results",
+    )
+    cache_directory: Path | None = Field(
+        default=None,
+        description="Directory for caching results (None = use default)",
+    )
+    fail_fast: bool = Field(
+        default=False,
+        description="Stop execution on first failure",
+    )
+    run_formatters_first: bool = Field(
+        default=True,
+        description="Run formatter checks before other checks",
+    )
+    enable_incremental: bool = Field(
+        default=True,
+        description="Only check modified files when possible",
+    )
+    verbose: bool = Field(
+        default=False,
+        description="Enable verbose output",
+    )
+    checks: list[QACheckConfig] = Field(
+        default_factory=list,
+        description="List of QA checks to execute",
+    )
+
+    @property
+    def fast_checks(self) -> list[QACheckConfig]:
+        """Get all fast stage checks."""
+        return [check for check in self.checks if check.is_fast_stage]
+
+    @property
+    def comprehensive_checks(self) -> list[QACheckConfig]:
+        """Get all comprehensive stage checks."""
+        return [check for check in self.checks if check.is_comprehensive_stage]
+
+    @property
+    def formatter_checks(self) -> list[QACheckConfig]:
+        """Get all formatter checks."""
+        return [check for check in self.checks if check.is_formatter]
+
+    @property
+    def enabled_checks(self) -> list[QACheckConfig]:
+        """Get all enabled checks."""
+        return [check for check in self.checks if check.enabled]

crackerjack/models/qa_results.py

@@ -0,0 +1,134 @@
+"""Result models for ACB Quality Assurance framework."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+class QAResultStatus(str, Enum):
+    """Status of a quality assurance check result."""
+
+    SUCCESS = "success"
+    FAILURE = "failure"
+    WARNING = "warning"
+    SKIPPED = "skipped"
+    ERROR = "error"
+
+
+class QACheckType(str, Enum):
+    """Type of quality assurance check."""
+
+    LINT = "lint"
+    FORMAT = "format"
+    TYPE = "type"  # Type checking (pyright, mypy, zuban)
+    SECURITY = "security"  # Secret leak prevention (gitleaks)
+    SAST = "sast"  # Static Application Security Testing (bandit, semgrep, pyscn)
+    COMPLEXITY = "complexity"  # Code complexity analysis
+    REFACTOR = "refactor"
+    TEST = "test"
+
+
+class QAResult(BaseModel):
+    """Result of a quality assurance check execution.
+
+    This model represents the outcome of running a single QA check,
+    including timing information, file changes, and detailed messages.
+    """
+
+    check_id: UUID = Field(
+        ...,
+        description="Unique identifier for the check that produced this result",
+    )
+    check_name: str = Field(
+        ...,
+        description="Human-readable name of the check (e.g., 'ruff-format', 'pyright')",
+    )
+    check_type: QACheckType = Field(
+        ...,
+        description="Category of the check (lint, format, type_check, etc.)",
+    )
+    status: QAResultStatus = Field(
+        ...,
+        description="Outcome status of the check",
+    )
+    message: str = Field(
+        default="",
+        description="Summary message describing the result",
+    )
+    details: str = Field(
+        default="",
+        description="Detailed output from the check (stdout/stderr)",
+    )
+    files_checked: list[Path] = Field(
+        default_factory=list,
+        description="List of files that were checked",
+    )
+    files_modified: list[Path] = Field(
+        default_factory=list,
+        description="List of files modified by the check (for formatters)",
+    )
+    issues_found: int = Field(
+        default=0,
+        description="Number of issues found (errors, warnings, style violations)",
+    )
+    issues_fixed: int = Field(
+        default=0,
+        description="Number of issues automatically fixed",
+    )
+    execution_time_ms: float = Field(
+        default=0.0,
+        description="Execution time in milliseconds",
+    )
+    timestamp: datetime = Field(
+        default_factory=datetime.now,
+        description="When the check was executed",
+    )
+    metadata: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional check-specific metadata",
+    )
+
+    @property
+    def is_success(self) -> bool:
+        """Check if the result indicates success.
+
+        Warnings are considered successful - they indicate potential issues
+        but don't fail the quality check.
+        """
+        return self.status in (QAResultStatus.SUCCESS, QAResultStatus.WARNING)
+
+    @property
+    def is_failure(self) -> bool:
+        """Check if the result indicates failure."""
+        return self.status == QAResultStatus.FAILURE
+
+    @property
+    def is_warning(self) -> bool:
+        """Check if the result indicates a warning."""
+        return self.status == QAResultStatus.WARNING
+
+    @property
+    def has_issues(self) -> bool:
+        """Check if any issues were found."""
+        return self.issues_found > 0
+
+    def to_summary(self) -> str:
+        """Generate a human-readable summary of the result."""
+        summary_parts = [f"{self.check_name}: {self.status.value}"]
+
+        if self.issues_found > 0:
+            summary_parts.append(f"{self.issues_found} issues found")
+
+        if self.issues_fixed > 0:
+            summary_parts.append(f"{self.issues_fixed} fixed")
+
+        if self.execution_time_ms > 0:
+            summary_parts.append(f"({self.execution_time_ms:.0f}ms)")
+
+        return " | ".join(summary_parts)

crackerjack/models/results.py

@@ -0,0 +1,35 @@
+import typing as t
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ExecutionResult:
+    operation_id: str
+    success: bool
+    duration_seconds: float
+    output: str = ""
+    error: str = ""
+    exit_code: int = 0
+    metadata: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
+
+
+@dataclass
+class ParallelExecutionResult:
+    group_name: str
+    total_operations: int
+    successful_operations: int
+    failed_operations: int
+    total_duration_seconds: float
+    results: list[ExecutionResult]
+
+    @property
+    def success_rate(self) -> float:
+        return (
+            self.successful_operations / self.total_operations
+            if self.total_operations > 0
+            else 0.0
+        )
+
+    @property
+    def overall_success(self) -> bool:
+        return self.failed_operations == 0