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

crackerjack/services/config_service.py

@@ -0,0 +1,198 @@
+"""Generic configuration loading and validation service."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+from loguru import logger
+from pydantic import BaseModel, ValidationError
+
+
+class ConfigService:
+    """Generic configuration loading and validation service."""
+
+    @staticmethod
+    def load_config(path: str | Path) -> dict[str, Any]:
+        """
+        Load configuration file based on extension.
+
+        Args:
+            path: Path to the configuration file
+
+        Returns:
+            Dictionary with configuration data
+
+        Raises:
+            ValueError: If file extension is not supported
+            FileNotFoundError: If the file doesn't exist
+            Exception: For other file loading errors
+        """
+        path = Path(path)
+
+        if not path.exists():
+            raise FileNotFoundError(f"Configuration file does not exist: {path}")
+
+        if path.suffix.lower() == ".json":
+            return ConfigService._load_json(path)
+        elif path.suffix.lower() in (".yml", ".yaml"):
+            return ConfigService._load_yaml(path)
+        elif path.suffix.lower() == ".toml":
+            return ConfigService._load_toml(path)
+        else:
+            raise ValueError(f"Unsupported config format: {path.suffix}")
+
+    @staticmethod
+    async def load_config_async(path: str | Path) -> dict[str, Any]:
+        """
+        Asynchronously load configuration file based on extension.
+
+        Args:
+            path: Path to the configuration file
+
+        Returns:
+            Dictionary with configuration data
+
+        Raises:
+            ValueError: If file extension is not supported
+            FileNotFoundError: If the file doesn't exist
+            Exception: For other file loading errors
+        """
+        from crackerjack.services.file_io_service import FileIOService
+
+        path = Path(path)
+
+        if not path.exists():
+            raise FileNotFoundError(f"Configuration file does not exist: {path}")
+
+        if path.suffix.lower() == ".json":
+            content = await FileIOService.read_text_file(path)
+            return json.loads(content)
+        elif path.suffix.lower() in (".yml", ".yaml"):
+            content = await FileIOService.read_text_file(path)
+            return yaml.safe_load(content)
+        elif path.suffix.lower() == ".toml":
+            content = await FileIOService.read_text_file(path)
+            import toml
+
+            return toml.loads(content)
+        else:
+            raise ValueError(f"Unsupported config format: {path.suffix}")
+
+    @staticmethod
+    def _load_json(path: Path) -> dict[str, Any]:
+        """Load JSON configuration."""
+        with path.open(encoding="utf-8") as f:
+            return json.load(f)
+
+    @staticmethod
+    def _load_yaml(path: Path) -> dict[str, Any]:
+        """Load YAML configuration."""
+        with path.open(encoding="utf-8") as f:
+            return yaml.safe_load(f)
+
+    @staticmethod
+    def _load_toml(path: Path) -> dict[str, Any]:
+        """Load TOML configuration."""
+        import toml
+
+        with path.open("r", encoding="utf-8") as f:
+            return toml.load(f)
+
+    @staticmethod
+    def validate_config(
+        config: dict[str, Any], model_class: type[BaseModel]
+    ) -> BaseModel:
+        """
+        Validate configuration against a Pydantic model.
+
+        Args:
+            config: Configuration dictionary to validate
+            model_class: Pydantic model class to validate against
+
+        Returns:
+            Validated Pydantic model instance
+
+        Raises:
+            ValidationError: If the configuration doesn't match the model
+        """
+        try:
+            return model_class.model_validate(config)
+        except ValidationError as e:
+            logger.error(f"Config validation failed: {e}")
+            raise
+
+    @staticmethod
+    def save_config(
+        config: dict[str, Any], path: str | Path, format: str | None = None
+    ) -> None:
+        """
+        Save configuration to file.
+
+        Args:
+            config: Configuration dictionary to save
+            path: Path to save the configuration to
+            format: Format to save as ('json', 'yaml', 'toml'). If None, inferred from path extension.
+        """
+        path = Path(path)
+        format = format or path.suffix.lower().lstrip(".")
+
+        # Create parent directories if they don't exist
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        if format == "json":
+            ConfigService._save_json(config, path)
+        elif format in ("yml", "yaml"):
+            ConfigService._save_yaml(config, path)
+        elif format == "toml":
+            ConfigService._save_toml(config, path)
+        else:
+            raise ValueError(f"Unsupported config format: {format}")
+
+    @staticmethod
+    def _save_json(config: dict[str, Any], path: Path) -> None:
+        """Save configuration as JSON."""
+        with path.open("w", encoding="utf-8") as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+
+    @staticmethod
+    def _save_yaml(config: dict[str, Any], path: Path) -> None:
+        """Save configuration as YAML."""
+        with path.open("w", encoding="utf-8") as f:
+            yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
+
+    @staticmethod
+    def _save_toml(config: dict[str, Any], path: Path) -> None:
+        """Save configuration as TOML."""
+        import toml
+
+        with path.open("w", encoding="utf-8") as f:
+            toml.dump(config, f)
+
+    @staticmethod
+    def merge_configs(
+        base_config: dict[str, Any], override_config: dict[str, Any]
+    ) -> dict[str, Any]:
+        """
+        Recursively merge two configuration dictionaries.
+
+        Args:
+            base_config: Base configuration
+            override_config: Configuration to merge on top of base
+
+        Returns:
+            Merged configuration dictionary
+        """
+        result = base_config.copy()
+
+        for key, value in override_config.items():
+            if (
+                key in result
+                and isinstance(result[key], dict)
+                and isinstance(value, dict)
+            ):
+                result[key] = ConfigService.merge_configs(result[key], value)
+            else:
+                result[key] = value
+
+        return result

crackerjack/services/config_template.py

@@ -1,5 +1,4 @@
 import hashlib
-import subprocess
 import typing as t
 from contextlib import suppress
 from dataclasses import dataclass, field
@@ -8,7 +7,7 @@ from pathlib import Path
 
 import tomli
 import yaml
-from rich.console import Console
+from acb.console import Console
 
 
 @dataclass
@@ -95,12 +94,13 @@ class ConfigTemplateService:
                 "stages": ["pre-push", "manual"],
             },
             {
-                "id": "pyright",
-                "name": "pyright-type-checking",
-                "entry": "uv run pyright",
+                "id": "zuban",
+                "name": "zuban-type-checking",
+                "entry": "uv run zuban check",
                 "language": "system",
-                "files": r"^crackerjack/.*\.py$",
-                "exclude": r"^crackerjack/(mcp|plugins)/.*\.py$|crackerjack/code_cleaner\.py$",
+                "args": ["--config-file", "mypy.ini", "./crackerjack"],
+                "pass_filenames": False,
+                "exclude": r"^tests/|^src/",
                 "stages": ["pre-push", "manual"],
             },
         ]
@@ -377,7 +377,7 @@ class ConfigTemplateService:
                 )
 
             self._update_version_tracking(project_path, "pre-commit", template.version)
-            self._invalidate_precommit_cache(project_path)
+            self._invalidate_cache(project_path)
 
             self.console.print(
                 f"[green]✅[/green] Updated {config_file.name} to version {template.version}"
@@ -452,7 +452,7 @@ class ConfigTemplateService:
         """Update version tracking file."""
         version_file = project_path / ".crackerjack-config.yaml"
 
-        data = {"version": "1.0.0", "configs": {}}
+        data: dict[str, t.Any] = {"version": "1.0.0", "configs": {}}
         if version_file.exists():
             with suppress(Exception):
                 with version_file.open() as f:
@@ -472,23 +472,10 @@ class ConfigTemplateService:
             with version_file.open("w") as f:
                 yaml.dump(data, f, default_flow_style=False, sort_keys=False)
 
-    def _invalidate_precommit_cache(self, project_path: Path) -> None:
-        """Invalidate pre-commit cache to ensure fresh environment."""
-        with suppress(Exception):
-            subprocess.run(
-                ["pre-commit", "clean"],
-                cwd=project_path,
-                capture_output=True,
-                text=True,
-                timeout=30,
-            )
-            subprocess.run(
-                ["pre-commit", "install"],
-                cwd=project_path,
-                capture_output=True,
-                text=True,
-                timeout=30,
-            )
+    def _invalidate_cache(self, project_path: Path) -> None:
+        """Invalidate cache to ensure fresh environment."""
+        # No-op in the new system - cache invalidation handled differently
+        pass
 
     def get_config_hash(self, config_path: Path) -> str:
         """Generate hash of configuration file for cache invalidation."""

crackerjack/services/coverage_badge_service.py

@@ -1,7 +1,8 @@
 from contextlib import suppress
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
 from .regex_patterns import SAFE_PATTERNS
 
@@ -9,7 +10,8 @@ from .regex_patterns import SAFE_PATTERNS
 class CoverageBadgeService:
     """Service for managing coverage badges in README.md files."""
 
-    def __init__(self, console: Console, project_root: Path) -> None:
+    @depends.inject
+    def __init__(self, console: Inject[Console], project_root: Path) -> None:
         self.console = console
         self.project_root = project_root
         self.readme_path = project_root / "README.md"
@@ -154,8 +156,8 @@ class CoverageBadgeService:
             if current_coverage is None:
                 return True  # No badge exists, should add one
 
-            # Only update if coverage changed by at least 0.1%
-            return abs(coverage_percent - current_coverage) >= 0.1
+            # Only update if coverage changed by at least 0.01% (more accurate reporting)
+            return abs(coverage_percent - current_coverage) >= 0.01
 
         except Exception:
             return True  # On error, attempt update

crackerjack/services/coverage_ratchet.py

@@ -3,20 +3,66 @@ import typing as t
 from datetime import datetime
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
 
+from crackerjack.models.protocols import CoverageRatchetProtocol
+from crackerjack.services.filesystem import FileSystemService
+from crackerjack.services.regex_patterns import update_coverage_requirement
 
-class CoverageRatchetService:
+
+class CoverageRatchetService(CoverageRatchetProtocol):
     MILESTONES = [15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 95, 100]
 
     TOLERANCE_MARGIN = 2.0
 
-    def __init__(self, pkg_path: Path, console: Console) -> None:
-        self.pkg_path = pkg_path
+    @depends.inject
+    def __init__(self, pkg_path: Path, console: Inject[Console]) -> None:
+        # Normalize to pathlib.Path to avoid async path behaviors
+        try:
+            self.pkg_path = Path(str(pkg_path))
+        except Exception:
+            self.pkg_path = Path(pkg_path)
         self.console = console
-        self.ratchet_file = pkg_path / ".coverage-ratchet.json"
-        self.pyproject_file = pkg_path / "pyproject.toml"
+        self.ratchet_file = self.pkg_path / ".coverage-ratchet.json"
+        self.pyproject_file = self.pkg_path / "pyproject.toml"
+
+    def initialize(self) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass
+
+    def health_check(self) -> bool:
+        return True
+
+    def shutdown(self) -> None:
+        pass
+
+    def metrics(self) -> dict[str, t.Any]:
+        return {}
+
+    def is_healthy(self) -> bool:
+        return True
+
+    def register_resource(self, resource: t.Any) -> None:
+        pass
+
+    def cleanup_resource(self, resource: t.Any) -> None:
+        pass
+
+    def record_error(self, error: Exception) -> None:
+        pass
+
+    def increment_requests(self) -> None:
+        pass
+
+    def get_custom_metric(self, name: str) -> t.Any:
+        return None
+
+    def set_custom_metric(self, name: str, value: t.Any) -> None:
+        pass
 
     def initialize_baseline(self, initial_coverage: float) -> None:
         if self.ratchet_file.exists():
@@ -136,7 +182,7 @@ class CoverageRatchetService:
     def _check_milestones(
         self, old_coverage: float, new_coverage: float, data: dict[str, t.Any]
     ) -> list[float]:
-        achieved_milestones = set[t.Any](data.get("milestones_achieved", []))
+        achieved_milestones = set(data.get("milestones_achieved", []))
         return [
             milestone
             for milestone in self.MILESTONES
@@ -184,13 +230,9 @@ class CoverageRatchetService:
         try:
             content = self.pyproject_file.read_text()
 
-            from crackerjack.services.regex_patterns import update_coverage_requirement
-
             updated_content = update_coverage_requirement(content, new_coverage)
 
             if updated_content != content:
-                from crackerjack.services.filesystem import FileSystemService
-
                 updated_content = (
                     FileSystemService.clean_trailing_whitespace_and_newlines(
                         updated_content
@@ -236,22 +278,6 @@ class CoverageRatchetService:
                 needed = milestone - current
                 return max(0.0, needed)
         return 0.0
-        data = self.get_ratchet_data()
-        if not data:
-            return {"status": "not_initialized"}
-
-        return {
-            "status": "active",
-            "current_coverage": data["baseline"],
-            "target_coverage": data["target"],
-            "next_milestone": data.get("next_milestone"),
-            "milestones_achieved": data.get("milestones_achieved", []),
-            "total_milestones": len(self.MILESTONES),
-            "progress_percent": (data["baseline"] / data["target"]) * 100,
-            "last_updated": data["last_updated"],
-            "history_count": len(data.get("history", [])),
-            "improvement_trend": self._calculate_trend(data),
-        }
 
     def _calculate_trend(self, data: dict[str, t.Any]) -> str:
         history = data.get("history", [])

crackerjack/services/debug.py

@@ -8,7 +8,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import depends
 from rich.panel import Panel
 from rich.table import Table
 
@@ -20,7 +21,7 @@ class AIAgentDebugger:
     def __init__(self, enabled: bool = False, verbose: bool = False) -> None:
         self.enabled = enabled
         self.verbose = verbose
-        self.console = Console(force_terminal=True, stderr=True)
+        self.console = depends.get_sync(Console)
         self.logger = get_logger("crackerjack.ai_agent.debug")
         self.session_id = f"debug_{int(time.time())}"
 
@@ -351,7 +352,9 @@ class AIAgentDebugger:
             f"Total test fixes: {self.total_test_fixes}, hook fixes: {self.total_hook_fixes}",
         )
 
-        self.console.print(table)
+        self.console.print(
+            Panel(table, title="AI Agent Debug Summary", border_style=border_style)
+        )
 
         if self.iteration_stats:
             self._print_iteration_breakdown(border_style)
@@ -397,7 +400,9 @@ class AIAgentDebugger:
                 else "N / A",
             )
 
-        self.console.print(table)
+        self.console.print(
+            Panel(table, title="Iteration Breakdown", border_style=border_style)
+        )
 
     def _print_agent_activity_breakdown(self, border_style: str = "red") -> None:
         agent_stats: dict[str, dict[str, t.Any]] = {}
@@ -436,7 +441,9 @@ class AIAgentDebugger:
             )
             table.add_row(agent, str(stats["activities"]), confidence_text)
 
-        self.console.print(table)
+        self.console.print(
+            Panel(table, title="Agent Activity Breakdown", border_style=border_style)
+        )
 
     def _print_total_statistics(self, border_style: str = "red") -> None:
         success_icon = "✅" if self.workflow_success else "❌"
@@ -475,7 +482,9 @@ class AIAgentDebugger:
             f"{total_fixes}/{total_issues} issues resolved",
         )
 
-        self.console.print(table)
+        self.console.print(
+            Panel(table, title="Total Workflow Statistics", border_style=border_style)
+        )
 
     def _print_mcp_operation_breakdown(self, border_style: str = "red") -> None:
         tool_stats = {}
@@ -510,7 +519,9 @@ class AIAgentDebugger:
                 f"{avg_duration: .2f}s" if avg_duration > 0 else "N / A",
             )
 
-        self.console.print(table)
+        self.console.print(
+            Panel(table, title="MCP Tool Usage", border_style=border_style)
+        )
 
     def log_iteration_start(self, iteration_number: int) -> None:
         if not self.enabled:

crackerjack/services/dependency_analyzer.py

@@ -67,10 +67,10 @@ class DependencyEdge:
 class DependencyGraph:
     """Complete dependency graph data structure."""
 
-    nodes: dict[str, DependencyNode] = field(default_factory=dict[str, t.Any])
+    nodes: dict[str, DependencyNode] = field(default_factory=dict)
     edges: list[DependencyEdge] = field(default_factory=list)
-    clusters: dict[str, list[str]] = field(default_factory=dict[str, t.Any])
-    metrics: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
+    clusters: dict[str, list[str]] = field(default_factory=dict)
+    metrics: dict[str, t.Any] = field(default_factory=dict)
     generated_at: datetime = field(default_factory=datetime.now)
 
     def to_dict(self) -> dict[str, t.Any]:
@@ -193,7 +193,7 @@ class DependencyAnalyzer:
         edges = self.dependency_graph.edges
 
         # Basic metrics
-        metrics = {
+        metrics: dict[str, t.Any] = {
             "total_nodes": len(nodes),
             "total_edges": len(edges),
             "total_clusters": len(self.dependency_graph.clusters),

crackerjack/services/dependency_monitor.py

@@ -68,8 +68,12 @@ class DependencyMonitorService:
 
     def _parse_dependencies(self) -> dict[str, str]:
         try:
-            with self.pyproject_path.open("rb") as f:
-                data = tomllib.load(f)
+            content = self.filesystem.read_file(self.pyproject_path)
+            if isinstance(content, bytes):
+                content_str = content.decode("utf-8")
+            else:
+                content_str = content
+            data = tomllib.loads(content_str)
 
             dependencies: dict[str, str] = {}
             project_data = data.get("project", {})
@@ -357,8 +361,7 @@ class DependencyMonitorService:
 
         cached_data = cache[cache_key]
         cache_age = current_time - cached_data["timestamp"]
-        is_fresh: bool = cache_age < 86400
-        return is_fresh
+        return cache_age < 86400
 
     def _create_major_update_from_cache(
         self,
@@ -452,13 +455,13 @@ class DependencyMonitorService:
 
         import requests
 
-        url = f"https://pypi.org/pypi/{package}/json"
+        url = f"https: //pypi.org/pypi/{package}/json"
         self._validate_pypi_url(url)
 
         parsed = urlparse(url)
 
         if parsed.scheme != "https" or parsed.netloc != "pypi.org":
-            msg = f"Invalid URL: only https://pypi.org URLs are allowed, got {url}"
+            msg = f"Invalid URL: only https: //pypi.org URLs are allowed, got {url}"
             raise ValueError(msg)
 
         response = requests.get(url, timeout=10, verify=True)
@@ -502,8 +505,7 @@ class DependencyMonitorService:
     def _get_release_date(self, releases: dict[str, t.Any], version: str) -> str:
         release_info = releases.get(version, [])
         if release_info:
-            upload_time: str = release_info[0].get("upload_time", "")
-            return upload_time
+            return release_info[0].get("upload_time", "")
         return ""
 
     def _has_breaking_changes(self, version: str) -> bool:
@@ -536,15 +538,13 @@ class DependencyMonitorService:
     def _load_update_cache(self) -> dict[str, t.Any]:
         with suppress(Exception):
             if self.cache_file.exists():
-                with self.cache_file.open() as f:
-                    return t.cast(dict[str, t.Any], json.load(f))
+                content = self.filesystem.read_file(self.cache_file)
+                return t.cast(dict[str, t.Any], json.loads(content))
         return {}
 
     def _save_update_cache(self, cache: dict[str, t.Any]) -> None:
         with suppress(Exception):
-            self.cache_file.parent.mkdir(exist_ok=True)
-            with self.cache_file.open("w") as f:
-                json.dump(cache, f, indent=2)
+            self.filesystem.write_file(self.cache_file, json.dumps(cache))
 
     def _report_vulnerabilities(
         self,

crackerjack/services/documentation_generator.py

@@ -4,7 +4,8 @@ import typing as t
 from pathlib import Path
 from string import Template
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
 from ..models.protocols import DocumentationGeneratorProtocol
 
@@ -125,7 +126,8 @@ $functions
 class DocumentationGeneratorImpl(DocumentationGeneratorProtocol):
     """Implementation of documentation generation from extracted API data."""
 
-    def __init__(self, console: Console) -> None:
+    @depends.inject
+    def __init__(self, console: Inject[Console]) -> None:
         self.console = console
         self.renderer = MarkdownTemplateRenderer()