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

crackerjack/services/intelligent_commit.py

@@ -0,0 +1,327 @@
+"""Intelligent commit message generation service."""
+
+import re
+import typing as t
+from pathlib import Path
+
+from rich.console import Console
+
+from crackerjack.models.protocols import GitInterface
+
+from .regex_patterns import CompiledPatternCache
+
+
+class CommitMessageGenerator:
+    """Generate intelligent commit messages based on changes and context."""
+
+    def __init__(self, console: Console, git_service: GitInterface) -> None:
+        """Initialize commit message generator."""
+        self.console = console
+        self.git = git_service
+
+        # Common change type patterns
+        self.patterns = {
+            "feat": [
+                r"add|create|implement|introduce",
+                r"new.*feature",
+                r"support.*for",
+            ],
+            "fix": [
+                r"fix|resolve|correct|repair",
+                r"bug|issue|problem",
+                r"error|exception|failure",
+            ],
+            "refactor": [
+                r"refactor|restructure|reorganize",
+                r"extract|move|rename",
+                r"improve.*structure",
+            ],
+            "test": [
+                r"test|spec|fixture",
+                r"coverage|assertion",
+                r"mock|stub",
+            ],
+            "docs": [
+                r"readme|documentation|doc",
+                r"comment|docstring",
+                r"\.md$|\.rst$|\.txt$",
+            ],
+            "style": [
+                r"format|style|lint",
+                r"whitespace|indentation",
+                r"prettier|black|ruff",
+            ],
+            "chore": [
+                r"config|setup|build",
+                r"dependency|requirement",
+                r"version|release",
+            ],
+        }
+
+    def generate_commit_message(
+        self,
+        include_body: bool = True,
+        conventional_commits: bool = True,
+    ) -> str:
+        """Generate an intelligent commit message based on staged changes."""
+        try:
+            # Get changed files and their changes
+            staged_files = self.git.get_staged_files()
+            if not staged_files:
+                return "chore: no changes to commit"
+
+            # Analyze file changes
+            change_analysis = self._analyze_changes(staged_files)
+
+            # Generate message components
+            commit_type = self._determine_commit_type(change_analysis)
+            scope = self._determine_scope(change_analysis)
+            subject = self._generate_subject(change_analysis)
+
+            # Build commit message
+            if conventional_commits:
+                header = self._build_conventional_header(commit_type, scope, subject)
+            else:
+                header = subject
+
+            if not include_body:
+                return header
+
+            # Add body with details
+            body = self._generate_body(change_analysis)
+
+            if body:
+                return f"{header}\n\n{body}"
+
+            return header
+
+        except Exception as e:
+            self.console.print(
+                f"[yellow]⚠️[/yellow] Error generating commit message: {e}"
+            )
+            return "chore: update files"
+
+    def _analyze_changes(self, staged_files: list[str]) -> dict[str, t.Any]:
+        """Analyze staged files to understand the nature of changes."""
+        analysis: dict[str, t.Any] = {
+            "files": staged_files,
+            "file_types": set(),
+            "directories": set(),
+            "total_files": len(staged_files),
+            "patterns_found": set(),
+        }
+
+        for file_path in staged_files:
+            path = Path(file_path)
+
+            # Track file types
+            if path.suffix:
+                analysis["file_types"].add(path.suffix)
+
+            # Track directories
+            if path.parent != Path():
+                analysis["directories"].add(str(path.parent))
+
+            # Check for patterns in file names
+            file_str = str(path).lower()
+            for commit_type, patterns in self.patterns.items():
+                for pattern in patterns:
+                    # Use safe compiled pattern cache instead of raw re.search
+                    compiled_pattern = (
+                        CompiledPatternCache.get_compiled_pattern_with_flags(
+                            f"commit_{commit_type}_{pattern}", pattern, re.IGNORECASE
+                        )
+                    )
+                    if compiled_pattern.search(file_str):
+                        analysis["patterns_found"].add(commit_type)
+
+        return analysis
+
+    def _determine_commit_type(self, analysis: dict[str, t.Any]) -> str:
+        """Determine the most appropriate commit type."""
+        patterns_found = analysis["patterns_found"]
+        files = analysis["files"]
+        file_types = analysis["file_types"]
+
+        # Check commit types in priority order
+        commit_type_checks = self._get_commit_type_checks()
+
+        for commit_type, check_func in commit_type_checks:
+            if check_func(patterns_found, files, file_types):
+                return commit_type
+
+        # Default to chore for misc changes
+        return "chore"
+
+    def _get_commit_type_checks(self) -> list[tuple[str, t.Callable[..., t.Any]]]:
+        """Get ordered list[t.Any] of commit type checks."""
+        return [
+            ("fix", self._is_fix_commit),
+            ("feat", self._is_feat_commit),
+            ("test", self._is_test_commit),
+            ("docs", self._is_docs_commit),
+            ("style", self._is_style_commit),
+            ("refactor", self._is_refactor_commit),
+        ]
+
+    def _is_fix_commit(
+        self, patterns: set[t.Any], files: list[t.Any], file_types: set[t.Any]
+    ) -> bool:
+        """Check if this is a fix commit."""
+        return "fix" in patterns
+
+    def _is_feat_commit(
+        self, patterns: set[t.Any], files: list[t.Any], file_types: set[t.Any]
+    ) -> bool:
+        """Check if this is a feature commit."""
+        return "feat" in patterns
+
+    def _is_test_commit(
+        self, patterns: set[t.Any], files: list[t.Any], file_types: set[t.Any]
+    ) -> bool:
+        """Check if this is a test commit."""
+        return "test" in patterns or any(
+            ".py" in f and "test" in f.lower() for f in files
+        )
+
+    def _is_docs_commit(
+        self, patterns: set[t.Any], files: list[t.Any], file_types: set[t.Any]
+    ) -> bool:
+        """Check if this is a documentation commit."""
+        return "docs" in patterns or any(
+            ext in file_types for ext in (".md", ".rst", ".txt")
+        )
+
+    def _is_style_commit(
+        self, patterns: set[t.Any], files: list[t.Any], file_types: set[t.Any]
+    ) -> bool:
+        """Check if this is a style commit."""
+        return (
+            "style" in patterns or len(files) > 5
+        )  # Multiple files suggest style changes
+
+    def _is_refactor_commit(
+        self, patterns: set[t.Any], files: list[t.Any], file_types: set[t.Any]
+    ) -> bool:
+        """Check if this is a refactor commit."""
+        return "refactor" in patterns
+
+    def _determine_scope(self, analysis: dict[str, t.Any]) -> str | None:
+        """Determine an appropriate scope for the commit."""
+        directories = analysis["directories"]
+        files = analysis["files"]
+
+        if len(directories) == 1:
+            # Single directory - use as scope
+            directory = list[str](directories)[0]
+            # Simplify common directory patterns
+            if "/" in directory:
+                return directory.split("/")[0]  # Use top-level directory
+            return directory
+
+        # Check for common patterns
+        if any("test" in f.lower() for f in files):
+            return "test"
+        if any("doc" in f.lower() for f in files):
+            return "docs"
+        if any(f.endswith(".py") for f in files):
+            return "core"
+        if any(f.endswith((".yml", ".yaml", ".toml", ".json")) for f in files):
+            return "config"
+
+        # No clear scope
+        return None
+
+    def _generate_subject(self, analysis: dict[str, t.Any]) -> str:
+        """Generate a descriptive subject line."""
+        files = analysis["files"]
+        file_types = analysis["file_types"]
+        total_files = analysis["total_files"]
+
+        # Handle single file changes
+        if total_files == 1:
+            file_path = Path(files[0])
+            file_name = file_path.stem
+
+            # Generate descriptive action based on file name
+            if "test" in file_name.lower():
+                return f"update {file_name} test"
+            elif file_path.suffix in (".md", ".rst", ".txt"):
+                return f"update {file_name} documentation"
+            elif "config" in file_name.lower():
+                return f"update {file_name} configuration"
+            else:
+                return f"update {file_name}"
+
+        # Handle multiple files
+        if total_files <= 3:
+            # List specific files
+            file_names = [Path(f).stem for f in files]
+            return f"update {', '.join(file_names)}"
+
+        # Handle bulk changes
+        if len(file_types) == 1:
+            file_type = list[t.Any](file_types)[0]
+            return f"update {total_files} {file_type} files"
+
+        return f"update {total_files} files"
+
+    def _build_conventional_header(
+        self, commit_type: str, scope: str | None, subject: str
+    ) -> str:
+        """Build conventional commit header format."""
+        if scope:
+            return f"{commit_type}({scope}): {subject}"
+        return f"{commit_type}: {subject}"
+
+    def _generate_body(self, analysis: dict[str, t.Any]) -> str:
+        """Generate detailed commit body."""
+        files = analysis["files"]
+        total_files = analysis["total_files"]
+
+        if total_files <= 3:
+            # List specific files for small changes
+            body_lines = ["Modified files:"]
+            for file_path in sorted(files):
+                body_lines.append(f"- {file_path}")
+            return "\n".join(body_lines)
+
+        # Summarize for larger changes
+        directories = analysis["directories"]
+        file_types = analysis["file_types"]
+
+        body_lines = [f"Updated {total_files} files across:"]
+
+        if directories:
+            body_lines.append("Directories:")
+            for directory in sorted(directories):
+                body_lines.append(f"- {directory}")
+
+        if file_types:
+            body_lines.append("File types:")
+            for file_type in sorted(file_types):
+                body_lines.append(f"- {file_type}")
+
+        return "\n".join(body_lines)
+
+    def commit_with_generated_message(
+        self,
+        include_body: bool = True,
+        conventional_commits: bool = True,
+        dry_run: bool = False,
+    ) -> bool:
+        """Generate commit message and create commit."""
+        message = self.generate_commit_message(
+            include_body=include_body,
+            conventional_commits=conventional_commits,
+        )
+
+        if dry_run:
+            self.console.print("[cyan]📝[/cyan] Generated commit message:")
+            self.console.print(f"[dim]{message}[/dim]")
+            return True
+
+        self.console.print(
+            f"[cyan]📝[/cyan] Committing with message: {message.split(chr(10))[0]}"
+        )
+        return self.git.commit(message)

crackerjack/services/log_manager.py

@@ -0,0 +1,289 @@
+import logging
+import os
+import shutil
+import time
+import typing as t
+from contextlib import suppress
+from pathlib import Path
+
+from acb import console
+
+# console imported from acb
+
+
+class LogManager:
+    def __init__(self, app_name: str = "crackerjack") -> None:
+        self.app_name = app_name
+        self._log_dir = self._get_log_directory()
+        self._setup_directories()
+
+    def _get_log_directory(self) -> Path:
+        cache_home = os.environ.get("XDG_CACHE_HOME")
+        base_dir = Path(cache_home) if cache_home else Path.home() / ".cache"
+
+        return base_dir / self.app_name / "logs"
+
+    def _setup_directories(self) -> None:
+        self._log_dir.mkdir(parents=True, exist_ok=True)
+
+        (self._log_dir / "debug").mkdir(exist_ok=True)
+        (self._log_dir / "error").mkdir(exist_ok=True)
+        (self._log_dir / "audit").mkdir(exist_ok=True)
+
+    @property
+    def log_dir(self) -> Path:
+        return self._log_dir
+
+    @property
+    def debug_dir(self) -> Path:
+        return self._log_dir / "debug"
+
+    @property
+    def error_dir(self) -> Path:
+        return self._log_dir / "error"
+
+    @property
+    def audit_dir(self) -> Path:
+        return self._log_dir / "audit"
+
+    def create_debug_log_file(self, session_id: str | None = None) -> Path:
+        timestamp = int(time.time())
+        if session_id:
+            filename = f"debug -{timestamp}-{session_id}.log"
+        else:
+            filename = f"debug -{timestamp}.log"
+
+        return self.debug_dir / filename
+
+    def create_error_log_file(self, error_type: str = "general") -> Path:
+        timestamp = int(time.time())
+        filename = f"error -{error_type}-{timestamp}.log"
+        return self.error_dir / filename
+
+    def rotate_logs(
+        self,
+        log_dir: Path,
+        pattern: str,
+        max_files: int = 10,
+        max_age_days: int = 30,
+    ) -> int:
+        if not log_dir.exists():
+            return 0
+
+        removed_count = 0
+        cutoff_time = time.time() - (max_age_days * 24 * 60 * 60)
+
+        log_files = sorted(
+            log_dir.glob(pattern),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+
+        for i, log_file in enumerate(log_files):
+            should_remove = False
+            reason = ""
+
+            if i >= max_files:
+                should_remove = True
+                reason = f"exceeds max files ({max_files})"
+
+            elif log_file.stat().st_mtime < cutoff_time:
+                should_remove = True
+                reason = f"older than {max_age_days} days"
+
+            if should_remove:
+                with suppress(OSError, PermissionError):
+                    log_file.unlink()
+                    removed_count += 1
+                    console.print(
+                        f"[dim]🗑️ Removed old log: {log_file.name} ({reason})[/ dim]",
+                    )
+
+        return removed_count
+
+    def cleanup_all_logs(
+        self,
+        debug_max_files: int = 10,
+        error_max_files: int = 20,
+        audit_max_files: int = 50,
+        max_age_days: int = 30,
+    ) -> dict[str, int]:
+        results = {}
+
+        results["debug"] = self.rotate_logs(
+            self.debug_dir,
+            "debug-*.log",
+            debug_max_files,
+            max_age_days,
+        )
+
+        results["error"] = self.rotate_logs(
+            self.error_dir,
+            "error-*.log",
+            error_max_files,
+            max_age_days,
+        )
+
+        results["audit"] = self.rotate_logs(
+            self.audit_dir,
+            "audit-*.log",
+            audit_max_files,
+            max_age_days,
+        )
+
+        return results
+
+    def migrate_legacy_logs(
+        self,
+        source_dir: Path,
+        dry_run: bool = False,
+    ) -> dict[str, int]:
+        if not source_dir.exists():
+            return {"moved": 0, "failed": 0, "found": 0}
+
+        debug_pattern = "crackerjack-debug-*.log"
+        legacy_files = list[t.Any](source_dir.glob(debug_pattern))
+
+        results = {"found": len(legacy_files), "moved": 0, "failed": 0}
+
+        if not legacy_files:
+            console.print("[green]✅ No legacy log files found to migrate[/ green]")
+            return results
+
+        console.print(
+            f"[yellow]📦 Found {len(legacy_files)} legacy debug log files to migrate[/ yellow]",
+        )
+
+        for legacy_file in legacy_files:
+            try:
+                parts = legacy_file.stem.split("-")
+                if len(parts) >= 3 and parts[-1].isdigit():
+                    timestamp = parts[-1]
+                else:
+                    timestamp = str(int(legacy_file.stat().st_mtime))
+
+                new_filename = f"debug -{timestamp}- migrated.log"
+                new_path = self.debug_dir / new_filename
+
+                if dry_run:
+                    console.print(
+                        f"[cyan]📋 Would move: {legacy_file.name} → {new_filename}[/ cyan]",
+                    )
+                    results["moved"] += 1
+                else:
+                    shutil.move(str(legacy_file), str(new_path))
+                    results["moved"] += 1
+                    console.print(
+                        f"[green]✅ Moved: {legacy_file.name} → {new_filename}[/ green]",
+                    )
+
+            except (OSError, ValueError) as e:
+                results["failed"] += 1
+                console.print(
+                    f"[red]❌ Failed to migrate {legacy_file.name}: {e}[/ red]",
+                )
+
+        return results
+
+    def get_log_stats(self) -> dict[str, dict[str, int | str | float]]:
+        stats: dict[str, dict[str, int | str | float]] = {}
+
+        for log_type, log_dir in (
+            ("debug", self.debug_dir),
+            ("error", self.error_dir),
+            ("audit", self.audit_dir),
+        ):
+            if log_dir.exists():
+                files = list[t.Any](log_dir.glob("*.log"))
+                total_size = sum(f.stat().st_size for f in files if f.exists())
+
+                stats[log_type] = {
+                    "count": len(files),
+                    "size_mb": round(total_size / (1024 * 1024), 2),
+                    "location": str(log_dir),
+                }
+            else:
+                stats[log_type] = {
+                    "count": 0,
+                    "size_mb": 0.0,
+                    "location": str(log_dir),
+                }
+
+        return stats
+
+    def setup_rotating_file_handler(
+        self,
+        logger: logging.Logger,
+        log_type: str = "debug",
+        max_bytes: int = 10 * 1024 * 1024,
+        backup_count: int = 5,
+    ) -> logging.FileHandler:
+        from logging.handlers import RotatingFileHandler
+
+        if log_type == "error":
+            log_dir = self.error_dir
+        elif log_type == "audit":
+            log_dir = self.audit_dir
+        else:
+            log_dir = self.debug_dir
+
+        log_file = log_dir / f"{log_type}.log"
+
+        handler = RotatingFileHandler(
+            log_file,
+            maxBytes=max_bytes,
+            backupCount=backup_count,
+            encoding="utf-8",
+        )
+
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s-%(message)s",
+        )
+        handler.setFormatter(formatter)
+
+        logger.addHandler(handler)
+
+        return handler
+
+    def print_log_summary(self) -> None:
+        stats = self.get_log_stats()
+
+        console.print("\n[bold]📊 Log File Summary[/ bold]")
+        console.print(f"[dim]Location: {self.log_dir}[/ dim]")
+
+        total_files: int = 0
+        total_size: float = 0.0
+
+        for log_type, data in stats.items():
+            count_raw = data["count"]
+            count: int = (
+                int(count_raw) if isinstance(count_raw, str) else t.cast(int, count_raw)
+            )
+            size_raw = data["size_mb"]
+            size: float = (
+                float(size_raw)
+                if isinstance(size_raw, str)
+                else t.cast(float, size_raw)
+            )
+
+            total_files += count
+            total_size += size
+
+            if count > 0:
+                console.print(f" {log_type.capitalize()}: {count} files, {size}MB")
+            else:
+                console.print(f" {log_type.capitalize()}: No files")
+
+        if total_files > 0:
+            console.print(
+                f"\n[bold]Total: {total_files} files, {total_size: .2f}MB[/ bold]",
+            )
+        else:
+            console.print("\n[dim]No log files found[/ dim]")
+
+
+log_manager = LogManager()
+
+
+def get_log_manager() -> LogManager:
+    return log_manager