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

crackerjack/services/documentation_service.py

@@ -3,7 +3,8 @@
 import typing as t
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
 from ..models.protocols import (
     APIExtractorProtocol,
@@ -17,17 +18,18 @@ from .documentation_generator import DocumentationGeneratorImpl
 class DocumentationServiceImpl(DocumentationServiceProtocol):
     """Main service for automated documentation generation and maintenance."""
 
+    @depends.inject
     def __init__(
         self,
-        console: Console,
+        console: Inject[Console],
         pkg_path: Path,
         api_extractor: APIExtractorProtocol | None = None,
         doc_generator: DocumentationGeneratorProtocol | None = None,
     ) -> None:
         self.console = console
         self.pkg_path = pkg_path
-        self.api_extractor = api_extractor or APIExtractorImpl(console)
-        self.doc_generator = doc_generator or DocumentationGeneratorImpl(console)
+        self.api_extractor = api_extractor or APIExtractorImpl()
+        self.doc_generator = doc_generator or DocumentationGeneratorImpl()
 
         # Define standard paths
         self.docs_dir = pkg_path / "docs"
@@ -38,58 +40,85 @@ class DocumentationServiceImpl(DocumentationServiceProtocol):
         # Ensure directories exist
         self._ensure_directories()
 
-    def extract_api_documentation(self, source_paths: list[Path]) -> dict[str, t.Any]:
-        """Extract API documentation from source code files."""
-        self.console.print(
-            "[cyan]📖[/cyan] Extracting API documentation from source files..."
-        )
-
-        # Categorize source files
+    def _categorize_source_files(
+        self, source_paths: list[Path]
+    ) -> dict[str, list[Path]]:
+        """Categorize source files by type."""
         python_files = [p for p in source_paths if p.suffix == ".py"]
-        protocol_files = [p for p in python_files if p.name == "protocols.py"]
-        service_files = [p for p in python_files if "/services/" in str(p)]
-        manager_files = [p for p in python_files if "/managers/" in str(p)]
-        cli_files = [p for p in python_files if "/cli/" in str(p)]
-        mcp_files = [
-            p for p in source_paths if "/mcp/" in str(p) or p.suffix in (".py", ".md")
-        ]
 
-        api_data = {}
+        return {
+            "python": python_files,
+            "protocol": [p for p in python_files if p.name == "protocols.py"],
+            "service": [p for p in python_files if "/services/" in str(p)],
+            "manager": [p for p in python_files if "/managers/" in str(p)],
+            "cli": [p for p in python_files if "/cli/" in str(p)],
+            "mcp": [
+                p
+                for p in source_paths
+                if "/mcp/" in str(p) or p.suffix in (".py", ".md")
+            ],
+        }
 
-        # Extract from Python files
-        if python_files:
-            python_data = self.api_extractor.extract_from_python_files(python_files)
-            api_data.update(python_data)
+    def _extract_specialized_apis(
+        self, categorized_files: dict[str, list[Path]]
+    ) -> dict[str, t.Any]:
+        """Extract specialized API documentation."""
+        api_data = {}
 
         # Extract protocol definitions
-        if protocol_files:
-            for protocol_file in protocol_files:
+        if categorized_files["protocol"]:
+            for protocol_file in categorized_files["protocol"]:
                 protocol_data = self.api_extractor.extract_protocol_definitions(
                     protocol_file
                 )
                 api_data.update(protocol_data)
 
         # Extract service interfaces
-        if service_files:
-            service_data = self.api_extractor.extract_service_interfaces(service_files)
+        if categorized_files["service"]:
+            service_data = self.api_extractor.extract_service_interfaces(
+                categorized_files["service"]
+            )
             api_data.update(service_data)
 
         # Extract manager interfaces
-        if manager_files:
-            manager_data = self.api_extractor.extract_service_interfaces(manager_files)
+        if categorized_files["manager"]:
+            manager_data = self.api_extractor.extract_service_interfaces(
+                categorized_files["manager"]
+            )
             if "services" in manager_data:
                 api_data["managers"] = manager_data["services"]
 
         # Extract CLI commands
-        if cli_files:
-            cli_data = self.api_extractor.extract_cli_commands(cli_files)
+        if categorized_files["cli"]:
+            cli_data = self.api_extractor.extract_cli_commands(categorized_files["cli"])
             api_data.update(cli_data)
 
         # Extract MCP tools
-        if mcp_files:
-            mcp_data = self.api_extractor.extract_mcp_tools(mcp_files)
+        if categorized_files["mcp"]:
+            mcp_data = self.api_extractor.extract_mcp_tools(categorized_files["mcp"])
             api_data.update(mcp_data)
 
+        return api_data
+
+    def extract_api_documentation(self, source_paths: list[Path]) -> dict[str, t.Any]:
+        """Extract API documentation from source code files."""
+        self.console.print(
+            "[cyan]📖[/cyan] Extracting API documentation from source files..."
+        )
+
+        categorized_files = self._categorize_source_files(source_paths)
+        api_data = {}
+
+        # Extract from Python files
+        if categorized_files["python"]:
+            python_data = self.api_extractor.extract_from_python_files(
+                categorized_files["python"]
+            )
+            api_data.update(python_data)
+
+        # Extract specialized APIs
+        api_data.update(self._extract_specialized_apis(categorized_files))
+
         self.console.print(
             f"[green]✅[/green] Extracted documentation from {len(source_paths)} files"
         )

crackerjack/services/enhanced_filesystem.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import hashlib
 import time
@@ -6,19 +8,30 @@ from pathlib import Path
 from typing import Any
 
 import aiofiles
+from acb.depends import Inject, depends
+from acb.logger import Logger
 
 from crackerjack.errors import FileError
-from crackerjack.models.protocols import FileSystemInterface
-from crackerjack.services.logging import LoggingContext, get_logger
+from crackerjack.models.protocols import (
+    EnhancedFileSystemServiceProtocol,
+    ServiceProtocol,
+)
+from crackerjack.services.logging import LoggingContext
 
 
 class FileCache:
-    def __init__(self, max_size: int = 1000, default_ttl: float = 300.0) -> None:
+    @depends.inject
+    def __init__(
+        self,
+        logger: Inject[Logger],
+        max_size: int = 1000,
+        default_ttl: float = 300.0,
+    ) -> None:
         self.max_size = max_size
         self.default_ttl = default_ttl
         self._cache: dict[str, dict[str, Any]] = {}
         self._access_times: dict[str, float] = {}
-        self.logger = get_logger("crackerjack.filesystem.cache")
+        self.logger = logger
 
     def get(self, key: str) -> str | None:
         if key not in self._cache:
@@ -78,11 +91,16 @@ class FileCache:
 
 
 class BatchFileOperations:
-    def __init__(self, batch_size: int = 10) -> None:
+    @depends.inject
+    def __init__(
+        self,
+        logger: Inject[Logger],
+        batch_size: int = 10,
+    ) -> None:
         self.batch_size = batch_size
         self.read_queue: list[tuple[Path, asyncio.Future[str]]] = []
         self.write_queue: list[tuple[Path, str, asyncio.Future[None]]] = []
-        self.logger = get_logger("crackerjack.filesystem.batch")
+        self.logger = logger
 
     async def queue_read(self, path: Path) -> str:
         future: asyncio.Future[str] = asyncio.Future()
@@ -161,18 +179,21 @@ class BatchFileOperations:
             future.set_exception(e)
 
 
-class EnhancedFileSystemService(FileSystemInterface):
+class EnhancedFileSystemService(EnhancedFileSystemServiceProtocol, ServiceProtocol):
+    @depends.inject
     def __init__(
         self,
+        logger: Inject[Logger],
         cache_size: int = 1000,
         cache_ttl: float = 300.0,
         batch_size: int = 10,
         enable_async: bool = True,
     ) -> None:
-        self.cache = FileCache(cache_size, cache_ttl)
+        # Use keyword args to avoid DI/positional ambiguity
+        self.cache = FileCache(max_size=cache_size, default_ttl=cache_ttl)
         self.batch_ops = BatchFileOperations(batch_size) if enable_async else None
         self.enable_async = enable_async
-        self.logger = get_logger("crackerjack.filesystem.enhanced")
+        self.logger = logger
 
         self._file_timestamps: dict[str, float] = {}
 
@@ -195,6 +216,9 @@ class EnhancedFileSystemService(FileSystemInterface):
 
     def write_file(self, path: str | Path, content: str) -> None:
         path_obj = Path(path) if isinstance(path, str) else path
+        # Validate content type before logging/length computation
+        if not isinstance(content, str):
+            raise TypeError("Content must be a string")
 
         with LoggingContext("write_file", path=str(path_obj), size=len(content)):
             self._write_file_direct(path_obj, content)
@@ -307,33 +331,45 @@ class EnhancedFileSystemService(FileSystemInterface):
         return self.cache.get(cache_key)
 
     @staticmethod
-    def _read_file_direct(path: Path) -> str:
-        try:
-            if not path.exists():
-                raise FileError(
-                    message=f"File does not exist: {path}",
-                    details=f"Attempted to read file at {path.absolute()}",
-                    recovery="Check file path and ensure file exists",
-                )
-            return path.read_text(encoding="utf-8")
-        except PermissionError as e:
+    def _validate_file_exists(path: Path) -> None:
+        """Validate that a file exists."""
+        if not path.exists():
+            raise FileError(
+                message=f"File does not exist: {path}",
+                details=f"Attempted to read file at {path.absolute()}",
+                recovery="Check file path and ensure file exists",
+            )
+
+    @staticmethod
+    def _handle_read_error(error: Exception, path: Path) -> None:
+        """Handle file read errors."""
+        if isinstance(error, PermissionError):
             raise FileError(
                 message=f"Permission denied reading file: {path}",
-                details=str(e),
+                details=str(error),
                 recovery="Check file permissions and user access rights",
-            ) from e
-        except UnicodeDecodeError as e:
+            ) from error
+        elif isinstance(error, UnicodeDecodeError):
             raise FileError(
                 message=f"Unable to decode file as UTF-8: {path}",
-                details=str(e),
+                details=str(error),
                 recovery="Ensure file is text - based and UTF-8 encoded",
-            ) from e
-        except OSError as e:
+            ) from error
+        elif isinstance(error, OSError):
             raise FileError(
                 message=f"System error reading file: {path}",
-                details=str(e),
+                details=str(error),
                 recovery="Check disk space and file system integrity",
-            ) from e
+            ) from error
+
+    @staticmethod
+    def _read_file_direct(path: Path) -> str:
+        try:
+            EnhancedFileSystemService._validate_file_exists(path)
+            return path.read_text(encoding="utf-8")
+        except (PermissionError, UnicodeDecodeError, OSError) as e:
+            EnhancedFileSystemService._handle_read_error(e, path)
+            raise  # Ensure type checker knows this doesn't return
 
     @staticmethod
     def _write_file_direct(path: Path, content: str) -> None:
@@ -441,3 +477,21 @@ class EnhancedFileSystemService(FileSystemInterface):
                 details=str(e),
                 recovery="Check parent directory permissions",
             ) from e
+
+    async def _on_start(self) -> None:
+        """
+        Lifecycle method called when the service is started.
+        """
+        self.logger.debug("EnhancedFileSystemService started")
+
+    async def _on_stop(self) -> None:
+        """
+        Lifecycle method called when the service is stopped.
+        """
+        self.logger.debug("EnhancedFileSystemService stopped")
+
+    async def _on_reload(self) -> None:
+        """
+        Lifecycle method called when the service is reloaded.
+        """
+        self.logger.debug("EnhancedFileSystemService reloaded")

crackerjack/services/enterprise_optimizer.py

@@ -313,7 +313,7 @@ class DataCompactionManager:
         return file_mtime < cutoff_date
 
     def _build_compaction_result(
-        self, data_type: str, rules: dict[str, t.Any], stats: dict[str, int]
+        self, data_type: str, rules: dict[str, t.Any], stats: dict[str, t.Any]
     ) -> dict[str, t.Any]:
         """Build the compaction result dictionary."""
         return {

crackerjack/services/error_pattern_analyzer.py

@@ -157,7 +157,7 @@ class ErrorPatternAnalyzer:
             error_type = pattern.error_type
             count = pattern.count
 
-            file_error_counts[file_path][error_type] += count
+            file_error_counts[file_path][error_type] += float(count)
             max_value = max(max_value, file_error_counts[file_path][error_type])
 
         # Create heat map cells
@@ -173,21 +173,21 @@ class ErrorPatternAnalyzer:
 
         for file_path in files:
             for error_type in error_types:
-                count = file_error_counts[file_path].get(error_type, 0)
-                if count > 0:
-                    intensity: float = count / max_value if max_value > 0 else 0
+                count_val = float(file_error_counts[file_path].get(error_type, 0))
+                if count_val > 0:
+                    intensity = count_val / max_value if max_value > 0 else 0.0  # type: ignore[assignment]
                     severity = self._get_severity_for_type(error_type)
 
                     cells.append(
                         HeatMapCell(
                             x=file_path,
                             y=error_type,
-                            value=count,
+                            value=count_val,
                             color_intensity=intensity,
                             tooltip_data={
                                 "file": file_path,
                                 "error_type": error_type,
-                                "count": count,
+                                "count": int(count_val),
                                 "severity": severity,
                             },
                             severity=severity,
@@ -300,7 +300,7 @@ class ErrorPatternAnalyzer:
         cells = []
         for time_label in time_labels:
             for error_type in error_types:
-                count = temporal_counts[time_label].get(error_type, 0)
+                count = float(temporal_counts[time_label].get(error_type, 0))
                 if count > 0:
                     cell = self._create_temporal_cell(
                         time_label, error_type, count, max_value
@@ -313,7 +313,7 @@ class ErrorPatternAnalyzer:
         self, time_label: str, error_type: str, count: float, max_value: float
     ) -> HeatMapCell:
         """Create a single temporal heatmap cell."""
-        intensity: float = count / max_value if max_value > 0 else 0
+        intensity = count / max_value if max_value > 0 else 0.0  # type: ignore[assignment]
         severity = self._get_severity_for_type(error_type)
 
         return HeatMapCell(
@@ -392,7 +392,7 @@ class ErrorPatternAnalyzer:
         cells = []
         for function_id in functions:
             for error_type in error_types:
-                count = function_error_counts[function_id].get(error_type, 0)
+                count = float(function_error_counts[function_id].get(error_type, 0))
                 if count > 0:
                     cell = self._create_function_cell(
                         function_id, error_type, count, max_value
@@ -405,7 +405,7 @@ class ErrorPatternAnalyzer:
         self, function_id: str, error_type: str, count: float, max_value: float
     ) -> HeatMapCell:
         """Create a single function heatmap cell."""
-        intensity: float = count / max_value if max_value > 0 else 0
+        intensity = count / max_value if max_value > 0 else 0.0  # type: ignore[assignment]
         severity = self._get_severity_for_type(error_type)
 
         return HeatMapCell(

crackerjack/services/file_filter.py

@@ -0,0 +1,221 @@
+"""Smart file filtering for incremental tool execution.
+
+Filters files based on git changes, patterns, and tool requirements.
+Part of Phase 10.2: Development Velocity Improvements.
+"""
+
+import typing as t
+from fnmatch import fnmatch
+from pathlib import Path
+
+from crackerjack.models.protocols import (
+    GitServiceProtocol,
+    ServiceProtocol,
+    SmartFileFilterProtocol,
+)
+
+
+class SmartFileFilter(SmartFileFilterProtocol, ServiceProtocol):
+    """Filter files for tool execution based on git changes and patterns.
+
+    Provides intelligent file filtering to enable incremental execution,
+    reducing unnecessary tool runs and improving feedback loops.
+    """
+
+    def __init__(
+        self,
+        git_service: GitServiceProtocol,
+        project_root: Path | None = None,
+    ):
+        """Initialize file filter.
+
+        Args:
+            git_service: Git service for repository operations
+            project_root: Project root directory (defaults to cwd)
+        """
+        self._git_service = git_service
+        self.project_root = project_root or Path.cwd()
+
+    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 get_changed_files(self, since: str = "HEAD") -> list[Path]:
+        """Get files changed since a git reference.
+
+        Args:
+            since: Git reference (commit, branch, tag, or "HEAD")
+
+        Returns:
+            List of changed file paths relative to project root
+        """
+        return self._git_service.get_changed_files_since(since, self.project_root)
+
+    def get_staged_files(self) -> list[Path]:
+        """Get currently staged files (in git index).
+
+        Returns:
+            List of staged file paths relative to project root
+        """
+        return self._git_service.get_staged_files(self.project_root)
+
+    def get_unstaged_files(self) -> list[Path]:
+        """Get unstaged modified files (working tree changes).
+
+        Returns:
+            List of unstaged file paths relative to project root
+        """
+        return self._git_service.get_unstaged_files(self.project_root)
+
+    def filter_by_pattern(self, files: list[Path], pattern: str) -> list[Path]:
+        """Filter files by glob pattern.
+
+        Args:
+            files: List of file paths to filter
+            pattern: Glob pattern (e.g., '*.py', '**/*.ts')
+
+        Returns:
+            List of files matching the pattern
+        """
+        return [
+            file_path
+            for file_path in files
+            if fnmatch(str(file_path), pattern) or fnmatch(file_path.name, pattern)
+        ]
+
+    def filter_by_tool(self, files: list[Path], tool: str) -> list[Path]:
+        """Filter files relevant to a specific tool.
+
+        Args:
+            files: List of file paths to filter
+            tool: Tool name (e.g., 'ruff-check', 'zuban', 'skylos')
+
+        Returns:
+            List of files applicable to the tool
+        """
+        # Tool-specific file type mappings
+        tool_patterns = {
+            # Python tools
+            "ruff-check": ["*.py"],
+            "ruff-format": ["*.py"],
+            "zuban": ["*.py"],
+            "skylos": ["*.py"],
+            "bandit": ["*.py"],
+            "refurb": ["*.py"],
+            "complexipy": ["*.py"],
+            "creosote": ["*.py"],
+            # Markdown tools
+            "mdformat": ["*.md"],
+            # YAML/TOML tools
+            "check-yaml": ["*.yaml", "*.yml"],
+            "check-toml": ["*.toml"],
+            # Text tools (apply to most files)
+            "trailing-whitespace": ["*"],
+            "end-of-file-fixer": ["*"],
+            "codespell": ["*"],
+            # Special tools
+            "validate-regex-patterns": ["*.py"],
+            "gitleaks": ["*"],
+            "uv-lock": ["pyproject.toml"],
+            "check-added-large-files": ["*"],
+        }
+
+        patterns = tool_patterns.get(tool, ["*"])
+
+        # Apply all patterns for the tool
+        filtered = []
+        for pattern in patterns:
+            filtered.extend(self.filter_by_pattern(files, pattern))
+
+        # Remove duplicates while preserving order
+        seen = set()
+        result = []
+        for file_path in filtered:
+            if file_path not in seen:
+                seen.add(file_path)
+                result.append(file_path)
+
+        return result
+
+    def get_all_modified_files(self) -> list[Path]:
+        """Get all modified files (staged + unstaged).
+
+        Returns:
+            Combined list of staged and unstaged files
+        """
+        staged = set(self.get_staged_files())
+        unstaged = set(self.get_unstaged_files())
+        all_modified = staged | unstaged
+
+        return sorted(all_modified)
+
+    def filter_by_extensions(
+        self, files: list[Path], extensions: list[str]
+    ) -> list[Path]:
+        """Filter files by file extensions.
+
+        Args:
+            files: List of file paths to filter
+            extensions: List of extensions (e.g., ['.py', '.md'])
+
+        Returns:
+            List of files with matching extensions
+        """
+        # Normalize extensions to include leading dot
+        normalized = [ext if ext.startswith(".") else f".{ext}" for ext in extensions]
+
+        return [file_path for file_path in files if file_path.suffix in normalized]
+
+    def get_python_files(self, files: list[Path]) -> list[Path]:
+        """Convenience method to filter Python files.
+
+        Args:
+            files: List of file paths to filter
+
+        Returns:
+            List of Python files (.py)
+        """
+        return self.filter_by_extensions(files, [".py"])
+
+    def get_markdown_files(self, files: list[Path]) -> list[Path]:
+        """Convenience method to filter Markdown files.
+
+        Args:
+            files: List of file paths to filter
+
+        Returns:
+            List of Markdown files (.md)
+        """
+        return self.filter_by_extensions(files, [".md"])

crackerjack/services/file_hasher.py

@@ -107,13 +107,11 @@ class FileHasher:
         return any(pattern in path_str for pattern in ignore_patterns)
 
     def invalidate_cache(self, file_path: Path | None = None) -> None:
-        if file_path:
-            stat = file_path.stat() if file_path.exists() else None
-            if stat:
-                cache_key = f"file_hash: {file_path}: {stat.st_mtime}: {stat.st_size}"
-                self.cache.file_hash_cache.invalidate(cache_key)
-        else:
-            self.cache.file_hash_cache.clear()
+        # CrackerjackCache doesn't have direct access to its underlying cache,
+        # so for targeted invalidation we would need to clear all file hashes
+        # For a specific file, we can't directly invalidate just that entry
+        # since the cache key contains mtime and size that would trigger invalidation naturally
+        pass  # No direct way to clear individual cache entries in CrackerjackCache
 
 
 class SmartFileWatcher: