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

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

@@ -0,0 +1,149 @@
+import asyncio
+import hashlib
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from .cache import CrackerjackCache
+
+
+class FileHasher:
+    def __init__(self, cache: CrackerjackCache | None = None) -> None:
+        self.cache = cache or CrackerjackCache()
+        self._executor = ThreadPoolExecutor(max_workers=4)
+
+    def get_file_hash(self, file_path: Path, algorithm: str = "md5") -> str:
+        if not file_path.exists():
+            return ""
+
+        cached_hash = self.cache.get_file_hash(file_path)
+        if cached_hash:
+            return cached_hash
+
+        file_hash = self._compute_file_hash(file_path, algorithm)
+        self.cache.set_file_hash(file_path, file_hash)
+        return file_hash
+
+    def get_directory_hash(
+        self,
+        directory: Path,
+        patterns: list[str] | None = None,
+    ) -> str:
+        if patterns is None:
+            patterns = ["*.py"]
+
+        file_hashes: list[str] = []
+        for pattern in patterns:
+            for file_path in directory.rglob(pattern):
+                if file_path.is_file():
+                    file_hash = self.get_file_hash(file_path)
+                    file_hashes.append(
+                        f"{file_path.relative_to(directory)}: {file_hash}",
+                    )
+
+        file_hashes.sort()
+        combined_content = "\n".join(file_hashes)
+        return hashlib.md5(combined_content.encode(), usedforsecurity=False).hexdigest()
+
+    def get_files_hash_list(self, files: list[Path]) -> list[str]:
+        return [
+            self.get_file_hash(file_path) for file_path in files if file_path.exists()
+        ]
+
+    async def get_files_hash_list_async(self, files: list[Path]) -> list[str]:
+        loop = asyncio.get_running_loop()
+        tasks = [
+            loop.run_in_executor(self._executor, self.get_file_hash, file_path, "md5")
+            for file_path in files
+            if file_path.exists()
+        ]
+        return await asyncio.gather(*tasks)
+
+    def has_files_changed(self, files: list[Path], cached_hashes: list[str]) -> bool:
+        if len(files) != len(cached_hashes):
+            return True
+
+        current_hashes = self.get_files_hash_list(files)
+        return current_hashes != cached_hashes
+
+    def _compute_file_hash(self, file_path: Path, algorithm: str = "md5") -> str:
+        hash_func = hashlib.new(algorithm)
+
+        try:
+            with file_path.open("rb") as f:
+                while chunk := f.read(8192):
+                    hash_func.update(chunk)
+            return hash_func.hexdigest()
+        except OSError:
+            return ""
+
+    def get_project_files_hash(self, project_path: Path) -> dict[str, str]:
+        patterns = ["*.py", "*.toml", "*.cfg", "*.ini", "*.yaml", "*.yml"]
+        file_hashes = {}
+
+        for pattern in patterns:
+            for file_path in project_path.rglob(pattern):
+                if file_path.is_file() and not self._should_ignore_file(file_path):
+                    relative_path = str(file_path.relative_to(project_path))
+                    file_hashes[relative_path] = self.get_file_hash(file_path)
+
+        return file_hashes
+
+    def _should_ignore_file(self, file_path: Path) -> bool:
+        ignore_patterns = [
+            ".git",
+            ".venv",
+            "__pycache__",
+            ".pytest_cache",
+            ".coverage",
+            ".crackerjack_cache",
+            "node_modules",
+            ".tox",
+            "dist",
+            "build",
+            "*.egg-info",
+        ]
+
+        path_str = str(file_path)
+        return any(pattern in path_str for pattern in ignore_patterns)
+
+    def invalidate_cache(self, file_path: Path | None = None) -> None:
+        # 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:
+    def __init__(self, file_hasher: FileHasher) -> None:
+        self.file_hasher = file_hasher
+        self._watched_files: dict[Path, tuple[float, int]] = {}
+
+    def register_files(self, files: list[Path]) -> None:
+        for file_path in files:
+            if file_path.exists():
+                stat = file_path.stat()
+                self._watched_files[file_path] = (stat.st_mtime, stat.st_size)
+
+    def check_changes(self) -> list[Path]:
+        changed_files: list[Path] = []
+
+        for file_path, (old_mtime, old_size) in self._watched_files.items():
+            if not file_path.exists():
+                changed_files.append(file_path)
+                continue
+
+            stat = file_path.stat()
+            if stat.st_mtime != old_mtime or stat.st_size != old_size:
+                changed_files.append(file_path)
+                self._watched_files[file_path] = (stat.st_mtime, stat.st_size)
+
+        return changed_files
+
+    def invalidate_changed_files(self) -> int:
+        changed_files = self.check_changes()
+
+        for file_path in changed_files:
+            self.file_hasher.invalidate_cache(file_path)
+
+        return len(changed_files)