crackerjack 0.31.10__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/services/config_merge.py

@@ -0,0 +1,542 @@
+import copy
+import io
+import typing as t
+from pathlib import Path
+
+import tomli
+import tomli_w
+import yaml
+from rich.console import Console
+
+from crackerjack.models.protocols import ConfigMergeServiceProtocol
+from crackerjack.services.filesystem import FileSystemService
+from crackerjack.services.git import GitService
+from crackerjack.services.logging import get_logger
+
+
+class ConfigMergeService(ConfigMergeServiceProtocol):
+    """Smart configuration file merging service.
+
+    Extracts and centralizes smart merge logic for:
+    - pyproject.toml files (preserves project identity, merges tool configs)
+    - .pre-commit-config.yaml files (adds missing repos, preserves existing hooks)
+    - .gitignore files (merges patterns while avoiding duplicates)
+    - Generic file appending with markers
+
+    Follows crackerjack's DRY, YAGNI, KISS principles.
+    """
+
+    def __init__(
+        self,
+        console: Console,
+        filesystem: FileSystemService,
+        git_service: GitService,
+    ) -> None:
+        self.console = console
+        self.filesystem = filesystem
+        self.git_service = git_service
+        self.logger = get_logger("crackerjack.config_merge")
+
+    def smart_merge_pyproject(
+        self,
+        source_content: dict[str, t.Any],
+        target_path: str | t.Any,
+        project_name: str,
+    ) -> dict[str, t.Any]:
+        """Smart merge pyproject.toml preserving project identity and merging tool configs."""
+        target_path = Path(target_path)
+
+        if not target_path.exists():
+            # No existing file, return source with project name replacement
+            return self._replace_project_name_in_config_value(
+                source_content, project_name
+            )
+
+        with target_path.open("rb") as f:
+            target_content = tomli.load(f)
+
+        # Ensure crackerjack dev dependency
+        self._ensure_crackerjack_dev_dependency(target_content, source_content)
+
+        # Merge tool configurations
+        self._merge_tool_configurations(target_content, source_content, project_name)
+
+        # Remove fixed coverage requirements (use ratchet system)
+        self._remove_fixed_coverage_requirements(target_content)
+
+        self.logger.info("Smart merged pyproject.toml", project_name=project_name)
+        return target_content
+
+    def smart_merge_pre_commit_config(
+        self,
+        source_content: dict[str, t.Any],
+        target_path: str | t.Any,
+        project_name: str,
+    ) -> dict[str, t.Any]:
+        """Smart merge .pre-commit-config.yaml adding missing repos."""
+        target_path = Path(target_path)
+
+        if not target_path.exists():
+            # No existing file, return source
+            return source_content
+
+        with target_path.open() as f:
+            target_content = yaml.safe_load(f) or {}
+
+        # Ensure target_content is a dict
+        if not isinstance(target_content, dict):
+            self.logger.warning(
+                f"Target config is not a dictionary, using source: {type(target_content)}"
+            )
+            return source_content
+
+        source_repos = source_content.get("repos", [])
+        target_repos = target_content.get("repos", [])
+
+        # Ensure target_repos is a list of dicts
+        if not isinstance(target_repos, list):
+            target_repos = []
+
+        # Get existing repo URLs to avoid duplicates
+        existing_repo_urls = {
+            repo.get("repo", "") for repo in target_repos if isinstance(repo, dict)
+        }
+
+        # Find new repos to add
+        new_repos = [
+            repo
+            for repo in source_repos
+            if isinstance(repo, dict) and repo.get("repo", "") not in existing_repo_urls
+        ]
+
+        if new_repos:
+            target_repos.extend(new_repos)
+            target_content["repos"] = target_repos
+            self.logger.info(
+                "Merged .pre-commit-config.yaml",
+                new_repos_count=len(new_repos),
+                project_name=project_name,
+            )
+
+        return target_content
+
+    def smart_append_file(
+        self,
+        source_content: str,
+        target_path: str | t.Any,
+        start_marker: str,
+        end_marker: str,
+        force: bool = False,
+    ) -> str:
+        """Smart append content to file with markers (for CLAUDE.md, etc)."""
+        target_path = Path(target_path)
+
+        if not target_path.exists():
+            # No existing file, return source content wrapped in markers
+            return f"{start_marker}\n{source_content.strip()}\n{end_marker}\n"
+
+        existing_content = target_path.read_text()
+
+        # Check if markers already exist
+        if start_marker in existing_content:
+            if force:
+                # Replace existing section
+                start_idx = existing_content.find(start_marker)
+                end_idx = existing_content.find(end_marker)
+                if end_idx != -1:
+                    end_idx += len(end_marker)
+                    existing_content = (
+                        existing_content[:start_idx] + existing_content[end_idx:]
+                    ).strip()
+            else:
+                # Already exists and not forced, return existing
+                return existing_content
+
+        # Append new section with markers
+        merged_content = existing_content.strip() + "\n\n" + start_marker + "\n"
+        merged_content += source_content.strip() + "\n"
+        merged_content += end_marker + "\n"
+
+        self.logger.info("Smart appended file with markers", path=str(target_path))
+        return merged_content
+
+    def smart_merge_gitignore(
+        self,
+        patterns: list[str],
+        target_path: str | t.Any,
+    ) -> str:
+        """Smart merge .gitignore patterns avoiding and cleaning out duplicates."""
+        target_path = Path(target_path)
+
+        if not target_path.exists():
+            return self._create_new_gitignore(target_path, patterns)
+
+        lines = target_path.read_text().splitlines()
+
+        # Parse existing content and extract patterns
+        parsed_content = self._parse_existing_gitignore_content(lines)
+
+        # Build merged content
+        merged_content = self._build_merged_gitignore_content(parsed_content, patterns)
+
+        # Write and log results
+        target_path.write_text(merged_content)
+        new_patterns_count = len(
+            [p for p in patterns if p not in parsed_content.existing_patterns]
+        )
+        all_patterns_count = len(parsed_content.existing_patterns) + new_patterns_count
+
+        self.logger.info(
+            "Smart merged .gitignore (cleaned duplicates)",
+            new_patterns_count=new_patterns_count,
+            total_crackerjack_patterns=all_patterns_count,
+        )
+        return merged_content
+
+    def _create_new_gitignore(self, target_path: Path, patterns: list[str]) -> str:
+        """Create a new .gitignore file with patterns."""
+        merged_content = "# Crackerjack patterns\n"
+        for pattern in patterns:
+            merged_content += f"{pattern}\n"
+        target_path.write_text(merged_content)
+        self.logger.info("Created .gitignore", new_patterns_count=len(patterns))
+        return merged_content
+
+    def _parse_existing_gitignore_content(self, lines: list[str]) -> t.Any:
+        """Parse existing .gitignore content, extracting patterns and non-Crackerjack lines."""
+
+        # Using a simple namespace class to group related data
+        class ParsedContent:
+            def __init__(self):
+                self.cleaned_lines = []
+                self.existing_patterns = set()
+
+        parsed = ParsedContent()
+        parser_state = self._init_parser_state()
+
+        for line in lines:
+            parser_state = self._process_gitignore_line(line, parsed, parser_state)
+
+        return parsed
+
+    def _init_parser_state(self) -> dict[str, bool]:
+        """Initialize parser state for gitignore parsing."""
+        return {
+            "inside_crackerjack_section": False,
+            "skip_empty_after_crackerjack": False,
+        }
+
+    def _process_gitignore_line(
+        self, line: str, parsed: t.Any, state: dict[str, bool]
+    ) -> dict[str, bool]:
+        """Process a single line during gitignore parsing."""
+        stripped = line.strip()
+
+        # Handle Crackerjack section headers
+        if self._is_crackerjack_header(stripped):
+            return self._handle_crackerjack_header(state)
+
+        # Handle empty lines after headers
+        if self._should_skip_empty_line(stripped, state):
+            state["skip_empty_after_crackerjack"] = False
+            return state
+
+        state["skip_empty_after_crackerjack"] = False
+
+        # Process patterns and lines
+        self._collect_pattern_if_present(stripped, parsed, state)
+        self._add_line_if_non_crackerjack(line, parsed, state)
+
+        return state
+
+    def _handle_crackerjack_header(self, state: dict[str, bool]) -> dict[str, bool]:
+        """Handle Crackerjack section header detection."""
+        if not state["inside_crackerjack_section"]:
+            state["inside_crackerjack_section"] = True
+            state["skip_empty_after_crackerjack"] = True
+        return state
+
+    def _should_skip_empty_line(self, stripped: str, state: dict[str, bool]) -> bool:
+        """Check if empty line should be skipped after Crackerjack header."""
+        return state["skip_empty_after_crackerjack"] and not stripped
+
+    def _collect_pattern_if_present(
+        self, stripped: str, parsed: t.Any, state: dict[str, bool]
+    ) -> None:
+        """Collect gitignore pattern if present on this line."""
+        if stripped and not stripped.startswith("#"):
+            parsed.existing_patterns.add(stripped)
+
+    def _add_line_if_non_crackerjack(
+        self, line: str, parsed: t.Any, state: dict[str, bool]
+    ) -> None:
+        """Add line to cleaned output if not in Crackerjack section."""
+        if not state["inside_crackerjack_section"]:
+            parsed.cleaned_lines.append(line)
+
+    def _is_crackerjack_header(self, line: str) -> bool:
+        """Check if a line is a Crackerjack section header."""
+        return line in ("# Crackerjack patterns", "# Crackerjack generated files")
+
+    def _build_merged_gitignore_content(
+        self, parsed_content: t.Any, new_patterns: list[str]
+    ) -> str:
+        """Build the final merged .gitignore content."""
+        # Remove trailing empty line if exists
+        if parsed_content.cleaned_lines and not parsed_content.cleaned_lines[-1]:
+            parsed_content.cleaned_lines.pop()
+
+        merged_content = "\n".join(parsed_content.cleaned_lines)
+        if merged_content:
+            merged_content += "\n"
+
+        # Add consolidated Crackerjack section
+        all_crackerjack_patterns = self._get_consolidated_patterns(
+            parsed_content.existing_patterns, new_patterns
+        )
+
+        if all_crackerjack_patterns:
+            merged_content += "\n# Crackerjack patterns\n"
+            for pattern in sorted(all_crackerjack_patterns):
+                merged_content += f"{pattern}\n"
+
+        return merged_content
+
+    def _get_consolidated_patterns(
+        self, existing_patterns: set[str], new_patterns: list[str]
+    ) -> list[str]:
+        """Get consolidated list of all Crackerjack patterns."""
+        new_patterns_to_add = [p for p in new_patterns if p not in existing_patterns]
+        return list(existing_patterns) + new_patterns_to_add
+
+    def write_pyproject_config(
+        self,
+        config: dict[str, t.Any],
+        target_path: str | t.Any,
+    ) -> None:
+        """Write pyproject.toml config with proper formatting."""
+        target_path = Path(target_path)
+
+        # Use BytesIO for proper TOML encoding
+        buffer = io.BytesIO()
+        tomli_w.dump(config, buffer)
+        content = buffer.getvalue().decode("utf-8")
+
+        # Clean trailing whitespace
+        content = FileSystemService.clean_trailing_whitespace_and_newlines(content)
+
+        with target_path.open("w", encoding="utf-8") as f:
+            f.write(content)
+
+        self.logger.debug("Wrote pyproject.toml config", path=str(target_path))
+
+    def write_pre_commit_config(
+        self,
+        config: dict[str, t.Any],
+        target_path: str | t.Any,
+    ) -> None:
+        """Write .pre-commit-config.yaml with proper formatting."""
+        target_path = Path(target_path)
+
+        yaml_content = yaml.dump(
+            config,
+            default_flow_style=False,
+            sort_keys=False,
+            width=float("inf"),
+        )
+        content = (
+            yaml_content.decode() if isinstance(yaml_content, bytes) else yaml_content
+        )
+        content = content or ""
+
+        # Clean trailing whitespace
+        content = FileSystemService.clean_trailing_whitespace_and_newlines(content)
+
+        with target_path.open("w") as f:
+            f.write(content)
+
+        self.logger.debug("Wrote .pre-commit-config.yaml", path=str(target_path))
+
+    def _ensure_crackerjack_dev_dependency(
+        self,
+        target_config: dict[str, t.Any],
+        source_config: dict[str, t.Any],
+    ) -> None:
+        """Ensure crackerjack is in dev dependencies."""
+        if "dependency-groups" not in target_config:
+            target_config["dependency-groups"] = {}
+
+        if "dev" not in target_config["dependency-groups"]:
+            target_config["dependency-groups"]["dev"] = []
+
+        dev_deps = target_config["dependency-groups"]["dev"]
+        if "crackerjack" not in str(dev_deps):
+            dev_deps.append("crackerjack")
+            self.logger.debug("Added crackerjack to dev dependencies")
+
+    def _merge_tool_configurations(
+        self,
+        target_config: dict[str, t.Any],
+        source_config: dict[str, t.Any],
+        project_name: str,
+    ) -> None:
+        """Merge tool configurations from source to target."""
+        source_tools = source_config.get("tool", {})
+
+        if "tool" not in target_config:
+            target_config["tool"] = {}
+
+        target_tools = target_config["tool"]
+
+        tools_to_merge = [
+            "ruff",
+            "pyright",
+            "bandit",
+            "vulture",
+            "refurb",
+            "complexipy",
+            "codespell",
+            "creosote",
+        ]
+
+        for tool_name in tools_to_merge:
+            if tool_name in source_tools:
+                if tool_name not in target_tools:
+                    target_tools[tool_name] = self._replace_project_name_in_tool_config(
+                        source_tools[tool_name], project_name
+                    )
+                    self.console.print(
+                        f"[green]➕[/green] Added [tool.{tool_name}] configuration"
+                    )
+                else:
+                    self._merge_tool_settings(
+                        target_tools[tool_name],
+                        source_tools[tool_name],
+                        tool_name,
+                        project_name,
+                    )
+
+        # Merge pytest markers
+        self._merge_pytest_markers(target_tools, source_tools)
+
+    def _merge_tool_settings(
+        self,
+        target_tool: dict[str, t.Any],
+        source_tool: dict[str, t.Any],
+        tool_name: str,
+        project_name: str,
+    ) -> None:
+        """Merge individual tool settings."""
+        updated_keys = []
+
+        for key, value in source_tool.items():
+            if key not in target_tool:
+                target_tool[key] = self._replace_project_name_in_config_value(
+                    value, project_name
+                )
+                updated_keys.append(key)
+
+        if updated_keys:
+            self.console.print(
+                f"[yellow]🔄[/yellow] Updated [tool.{tool_name}] with: {', '.join(updated_keys)}"
+            )
+
+    def _merge_pytest_markers(
+        self,
+        target_tools: dict[str, t.Any],
+        source_tools: dict[str, t.Any],
+    ) -> None:
+        """Merge pytest markers avoiding duplicates."""
+        if "pytest" not in source_tools or "pytest" not in target_tools:
+            return
+
+        source_pytest = source_tools["pytest"]
+        target_pytest = target_tools["pytest"]
+
+        if "ini_options" not in source_pytest or "ini_options" not in target_pytest:
+            return
+
+        source_markers = source_pytest["ini_options"].get("markers", [])
+        target_markers = target_pytest["ini_options"].get("markers", [])
+
+        # Extract existing marker names
+        existing_marker_names = {marker.split(": ")[0] for marker in target_markers}
+        new_markers = [
+            marker
+            for marker in source_markers
+            if marker.split(": ")[0] not in existing_marker_names
+        ]
+
+        if new_markers:
+            target_markers.extend(new_markers)
+            self.console.print(
+                f"[green]➕[/green] Added pytest markers: {len(new_markers)}"
+            )
+
+    def _remove_fixed_coverage_requirements(
+        self,
+        target_config: dict[str, t.Any],
+    ) -> None:
+        """Remove fixed coverage requirements to use ratchet system."""
+        target_coverage = (
+            target_config.get("tool", {}).get("pytest", {}).get("ini_options", {})
+        )
+
+        # Remove --cov-fail-under from addopts
+        addopts = target_coverage.get("addopts", "")
+        if isinstance(addopts, str):
+            original_addopts = addopts
+
+            # Remove coverage fail-under flags
+            from crackerjack.services.regex_patterns import remove_coverage_fail_under
+
+            addopts = remove_coverage_fail_under(addopts).strip()
+            addopts = " ".join(addopts.split())  # Normalize whitespace
+
+            if original_addopts != addopts:
+                target_coverage["addopts"] = addopts
+                self.console.print(
+                    "[green]🔄[/green] Removed fixed coverage requirement (using ratchet system)"
+                )
+
+        # Reset coverage.report.fail_under to 0
+        coverage_report = (
+            target_config.get("tool", {}).get("coverage", {}).get("report", {})
+        )
+        if "fail_under" in coverage_report:
+            original_fail_under = coverage_report["fail_under"]
+            coverage_report["fail_under"] = 0
+            self.console.print(
+                f"[green]🔄[/green] Reset coverage.report.fail_under from {original_fail_under} to 0 (ratchet system)"
+            )
+
+    def _replace_project_name_in_tool_config(
+        self, tool_config: dict[str, t.Any], project_name: str
+    ) -> dict[str, t.Any]:
+        """Replace project name in tool configuration."""
+        if project_name == "crackerjack":
+            return tool_config
+
+        result = copy.deepcopy(tool_config)
+        return self._replace_project_name_in_config_value(result, project_name)
+
+    def _replace_project_name_in_config_value(
+        self, value: t.Any, project_name: str
+    ) -> t.Any:
+        """Recursively replace project name in configuration values."""
+        if project_name == "crackerjack":
+            return value
+
+        if isinstance(value, str):
+            return value.replace("crackerjack", project_name)
+        elif isinstance(value, list):
+            return [
+                self._replace_project_name_in_config_value(item, project_name)
+                for item in value
+            ]
+        elif isinstance(value, dict):
+            return {
+                key: self._replace_project_name_in_config_value(val, project_name)
+                for key, val in value.items()
+            }
+        return value

crackerjack/services/contextual_ai_assistant.py

@@ -110,14 +110,13 @@ class ContextualAIAssistant:
                     category="testing",
                     priority="high",
                     title="Add Test Suite",
-                    description="No test directory found. Adding tests improves code reliability and enables CI/CD.",
+                    description="No test directory found. Adding tests improves code reliability and enables CI / CD.",
                     action_command="python -m crackerjack -t",
-                    reasoning="Projects without tests have 40% more bugs in production",
+                    reasoning="Projects without tests have 40 % more bugs in production",
                     confidence=0.9,
                 ),
             )
         elif context.test_coverage < 75:
-            # Calculate next milestone
             milestones = [15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 100]
             next_milestone = next(
                 (m for m in milestones if m > context.test_coverage), 100
@@ -127,10 +126,10 @@ class ContextualAIAssistant:
                 AIRecommendation(
                     category="testing",
                     priority="medium",
-                    title="Progress Toward 100% Coverage",
-                    description=f"Current coverage: {context.test_coverage:.1f}%. Next milestone: {next_milestone}% on the journey to 100%.",
+                    title="Progress Toward 100 % Coverage",
+                    description=f"Current coverage: {context.test_coverage: .1f}%. Next milestone: {next_milestone}% on the journey to 100 %.",
                     action_command="python -m crackerjack -t",
-                    reasoning="Coverage ratchet system prevents regression and targets 100% coverage incrementally",
+                    reasoning="Coverage ratchet system prevents regression and targets 100 % coverage incrementally",
                     confidence=0.85,
                 ),
             )
@@ -224,8 +223,8 @@ class ContextualAIAssistant:
                     category="workflow",
                     priority="medium",
                     title="Set Up CI / CD Pipeline",
-                    description="No CI/CD configuration found. Automated testing and deployment improve reliability.",
-                    reasoning="CI/CD prevents 60% of deployment issues and improves team productivity",
+                    description="No CI / CD configuration found. Automated testing and deployment improve reliability.",
+                    reasoning="CI / CD prevents 60 % of deployment issues and improves team productivity",
                     confidence=0.8,
                 ),
             )
@@ -328,7 +327,7 @@ class ContextualAIAssistant:
 
     def _has_ci_cd_config(self) -> bool:
         ci_files = [
-            ".github/workflows",
+            ".github / workflows",
             ".gitlab-ci.yml",
             "azure-pipelines.yml",
             "Jenkinsfile",
@@ -375,7 +374,7 @@ class ContextualAIAssistant:
 
         with suppress(Exception):
             result = subprocess.run(
-                ["git", "log", "-1", "--format=%ct"],
+                ["git", "log", "- 1", "--format=% ct"],
                 check=False,
                 capture_output=True,
                 text=True,
@@ -395,7 +394,7 @@ class ContextualAIAssistant:
 
         with suppress(Exception):
             result = subprocess.run(
-                ["uv", "run", "bandit", "-r", ".", "-f", "json"],
+                ["uv", "run", "bandit", "- r", ".", "- f", "json"],
                 check=False,
                 capture_output=True,
                 text=True,
@@ -441,12 +440,12 @@ class ContextualAIAssistant:
     def display_recommendations(self, recommendations: list[AIRecommendation]) -> None:
         if not recommendations:
             self.console.print(
-                "[green]✨ Great job! No immediate recommendations.[/green]",
+                "[green]✨ Great job ! No immediate recommendations.[/ green]",
             )
             return
 
-        self.console.print("\n[bold cyan]🤖 AI Assistant Recommendations[/bold cyan]")
-        self.console.print("[dim]Based on your current project context[/dim]\n")
+        self.console.print("\n[bold cyan]🤖 AI Assistant Recommendations[/ bold cyan]")
+        self.console.print("[dim]Based on your current project context[/ dim]\n")
 
         for i, rec in enumerate(recommendations, 1):
             priority_color = {"high": "red", "medium": "yellow", "low": "blue"}.get(
@@ -466,23 +465,23 @@ class ContextualAIAssistant:
             }.get(rec.category, "💡")
 
             self.console.print(
-                f"[bold]{i}. {category_emoji} {rec.title}[/bold] [{priority_color}]({rec.priority})[/{priority_color}]",
+                f"[bold]{i}. {category_emoji} {rec.title}[/ bold] [{priority_color}]({rec.priority})[/{priority_color}]",
             )
             self.console.print(f" {rec.description}")
 
             if rec.action_command:
                 self.console.print(
-                    f" [dim]Run:[/dim] [cyan]{rec.action_command}[/cyan]",
+                    f" [dim]Run: [/ dim] [cyan]{rec.action_command}[/ cyan]",
                 )
 
             if rec.reasoning:
-                self.console.print(f" [dim italic]💭 {rec.reasoning}[/dim italic]")
+                self.console.print(f" [dim italic]💭 {rec.reasoning}[/ dim italic]")
 
             confidence_bar = "█" * int(rec.confidence * 10) + "▒" * (
                 10 - int(rec.confidence * 10)
             )
             self.console.print(
-                f" [dim]Confidence: [{confidence_bar}] {rec.confidence:.1%}[/dim]",
+                f" [dim]Confidence: [{confidence_bar}] {rec.confidence: .1 %}[/ dim]",
             )
 
             if i < len(recommendations):
@@ -491,7 +490,6 @@ class ContextualAIAssistant:
     def get_quick_help(self, query: str) -> str:
         query_lower = query.lower()
 
-        # Check for more specific patterns first
         if "coverage" in query_lower:
             return "Check test coverage with: python -m crackerjack -t\nView HTML report: uv run coverage html"