crackerjack 0.33.0__py3-none-any.whl → 0.33.2__py3-none-any.whl

crackerjack/services/coverage_badge_service.py

@@ -0,0 +1,171 @@
+from contextlib import suppress
+from pathlib import Path
+
+from rich.console import Console
+
+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:
+        self.console = console
+        self.project_root = project_root
+        self.readme_path = project_root / "README.md"
+
+    def update_readme_coverage_badge(self, coverage_percent: float) -> bool:
+        """Update or insert coverage badge in README.md with current coverage percentage."""
+        if not self.readme_path.exists():
+            self.console.print(
+                "[yellow]⚠️[/yellow] README.md not found, skipping badge update"
+            )
+            return False
+
+        try:
+            readme_content = self.readme_path.read_text(encoding="utf-8")
+            badge_url = self._generate_badge_url(coverage_percent)
+
+            if self._has_coverage_badge(readme_content):
+                updated_content = self._update_existing_badge(readme_content, badge_url)
+                action = "updated"
+            else:
+                updated_content = self._insert_new_badge(readme_content, badge_url)
+                action = "added"
+
+            if updated_content != readme_content:
+                self.readme_path.write_text(updated_content, encoding="utf-8")
+                self.console.print(
+                    f"[green]📊[/green] Coverage badge {action}: {coverage_percent:.1f}%"
+                )
+                return True
+            else:
+                return False
+
+        except Exception as e:
+            self.console.print(f"[red]❌[/red] Failed to update coverage badge: {e}")
+            return False
+
+    def _generate_badge_url(self, coverage_percent: float) -> str:
+        """Generate shields.io badge URL with appropriate color coding."""
+        color = self._get_badge_color(coverage_percent)
+        # URL encode the % symbol as %25
+        encoded_percent = f"{coverage_percent:.1f}%25"
+        return f"https://img.shields.io/badge/coverage-{encoded_percent}-{color}"
+
+    def _get_badge_color(self, coverage_percent: float) -> str:
+        """Determine badge color based on coverage percentage."""
+        if coverage_percent < 50:
+            return "red"
+        elif coverage_percent < 80:
+            return "yellow"
+        return "brightgreen"
+
+    def _has_coverage_badge(self, content: str) -> bool:
+        """Check if README already contains a coverage badge."""
+        # Use safe pattern for badge detection
+        return SAFE_PATTERNS["detect_coverage_badge"].search(content) is not None
+
+    def _update_existing_badge(self, content: str, new_badge_url: str) -> str:
+        """Replace existing coverage badge with new one."""
+        # Try different safe patterns for badge replacement
+        patterns_to_try = [
+            "update_coverage_badge_url",
+            "update_coverage_badge_any",
+            "update_shields_coverage_url",
+        ]
+
+        for pattern_name in patterns_to_try:
+            pattern_obj = SAFE_PATTERNS[pattern_name]
+            # Use the pattern and manually replace NEW_BADGE_URL with actual URL
+            temp_content = pattern_obj.apply(content)
+            if temp_content != content:
+                # Replace placeholder with actual URL
+                new_content = temp_content.replace("NEW_BADGE_URL", new_badge_url)
+                return new_content
+
+        return content
+
+    def _insert_new_badge(self, content: str, badge_url: str) -> str:
+        """Insert new coverage badge in the appropriate location."""
+        lines = content.split("\n")
+
+        # Find the badge section (after title, before first heading)
+        insert_index = self._find_badge_insertion_point(lines)
+
+        if insert_index is not None:
+            coverage_badge = f"![Coverage]({badge_url})"
+            lines.insert(insert_index, coverage_badge)
+            return "\n".join(lines)
+        # Fallback: add after title
+        return self._insert_after_title(content, badge_url)
+
+    def _find_badge_insertion_point(self, lines: list[str]) -> int | None:
+        """Find the best location to insert the coverage badge."""
+        # Look for existing badge lines
+        badge_lines = [
+            i for i, line in enumerate(lines) if line.strip().startswith(("[![", "!["))
+        ]
+
+        if badge_lines:
+            # Insert after the last existing badge
+            return badge_lines[-1] + 1
+
+        # Look for first non-empty line after title
+        title_found = False
+        for i, line in enumerate(lines):
+            if line.startswith("#") and not title_found:
+                title_found = True
+                continue
+            elif title_found and line.strip() == "":
+                continue
+            elif title_found and line.strip():
+                return i
+
+        return None
+
+    def _insert_after_title(self, content: str, badge_url: str) -> str:
+        """Fallback method to insert badge after the title."""
+        lines = content.split("\n")
+
+        # Find title line
+        for i, line in enumerate(lines):
+            if line.startswith("#"):
+                # Insert after title with blank line
+                coverage_badge = f"![Coverage]({badge_url})"
+                if i + 1 < len(lines) and lines[i + 1].strip() == "":
+                    lines.insert(i + 2, coverage_badge)
+                else:
+                    lines.insert(i + 1, "")
+                    lines.insert(i + 2, coverage_badge)
+                break
+
+        return "\n".join(lines)
+
+    def should_update_badge(self, coverage_percent: float) -> bool:
+        """Check if badge should be updated based on coverage change."""
+        if not self.readme_path.exists():
+            return False
+
+        try:
+            content = self.readme_path.read_text(encoding="utf-8")
+            current_coverage = self._extract_current_coverage(content)
+
+            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
+
+        except Exception:
+            return True  # On error, attempt update
+
+    def _extract_current_coverage(self, content: str) -> float | None:
+        """Extract current coverage percentage from existing badge."""
+        match = SAFE_PATTERNS["extract_coverage_percentage"].search(content)
+
+        if match:
+            with suppress(ValueError):
+                return float(match.group(1))
+
+        return None

crackerjack/services/coverage_ratchet.py

@@ -9,7 +9,7 @@ from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
 
 class CoverageRatchetService:
     MILESTONES = [15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 95, 100]
-    # 2% tolerance margin for coverage fluctuations to prevent test flakiness
+
     TOLERANCE_MARGIN = 2.0
 
     def __init__(self, pkg_path: Path, console: Console) -> None:
@@ -22,7 +22,7 @@ class CoverageRatchetService:
         if self.ratchet_file.exists():
             return
 
-        ratchet_data = {
+        ratchet_data: dict[str, t.Any] = {
             "baseline": initial_coverage,
             "current_minimum": initial_coverage,
             "target": 100.0,
@@ -47,44 +47,39 @@ class CoverageRatchetService:
     def get_ratchet_data(self) -> dict[str, t.Any]:
         if not self.ratchet_file.exists():
             return {}
-        return json.loads(self.ratchet_file.read_text())
+        return t.cast(dict[str, t.Any], json.loads(self.ratchet_file.read_text()))
+
+    def get_status_report(self) -> dict[str, t.Any]:
+        """Get status report for coverage ratchet service."""
+        return self.get_ratchet_data()
 
     def get_baseline(self) -> float:
-        return self.get_ratchet_data().get("baseline", 0.0)
+        data = self.get_ratchet_data()
+        baseline = data.get("baseline")
+        return float(baseline) if baseline is not None else 0.0
 
     def get_baseline_coverage(self) -> float:
-        """Protocol method: Get baseline coverage."""
         return self.get_baseline()
 
     def update_baseline_coverage(self, new_coverage: float) -> bool:
-        """Protocol method: Update baseline coverage."""
-        return self.update_coverage(new_coverage).get("success", False)
+        result: bool = self.update_coverage(new_coverage).get("success", False)
+        return result
 
     def is_coverage_regression(self, current_coverage: float) -> bool:
-        """Protocol method: Check if coverage is a regression."""
         baseline = self.get_baseline()
         return current_coverage < (baseline - self.TOLERANCE_MARGIN)
 
-    def get_coverage_improvement_needed(self) -> float:
-        """Protocol method: Get coverage improvement needed."""
+    def calculate_coverage_gap(self) -> float:
         data = self.get_ratchet_data()
-        baseline = data.get("baseline", 0.0)
+        baseline = data.get("baseline")
+        baseline = float(baseline) if baseline is not None else 0.0
         next_milestone = data.get("next_milestone")
+        next_milestone = float(next_milestone) if next_milestone is not None else None
         if next_milestone:
             return next_milestone - baseline
         return 100.0 - baseline
 
     def update_coverage(self, new_coverage: float) -> dict[str, t.Any]:
-        """Update coverage with 2% tolerance margin to prevent test flakiness.
-
-        Behavior:
-        - Coverage below (baseline - 2%): FAIL (regression)
-        - Coverage within ±2% of baseline: PASS (maintained)
-        - Coverage above baseline: PASS (improved, updates baseline)
-
-        This prevents failures due to small coverage fluctuations while
-        still catching significant regressions.
-        """
         if not self.ratchet_file.exists():
             self.initialize_baseline(new_coverage)
             return {
@@ -99,7 +94,6 @@ class CoverageRatchetService:
         data = self.get_ratchet_data()
         current_baseline = data["baseline"]
 
-        # Check if coverage is below the tolerance margin (baseline - 2%)
         tolerance_threshold = current_baseline - self.TOLERANCE_MARGIN
         if new_coverage < tolerance_threshold:
             return {
@@ -126,11 +120,12 @@ class CoverageRatchetService:
                 "next_milestone": self._get_next_milestone(new_coverage),
                 "points_to_next": (next_milestone - new_coverage)
                 if (next_milestone := self._get_next_milestone(new_coverage))
+                is not None
                 else 0,
                 "allowed": True,
                 "baseline_updated": True,
             }
-        # Coverage is within tolerance margin - treat as maintained
+
         return {
             "status": "maintained",
             "message": f"Coverage maintained at {new_coverage: .2f}% (within {self.TOLERANCE_MARGIN}% tolerance margin)",
@@ -141,7 +136,7 @@ class CoverageRatchetService:
     def _check_milestones(
         self, old_coverage: float, new_coverage: float, data: dict[str, t.Any]
     ) -> list[float]:
-        achieved_milestones = set(data.get("milestones_achieved", []))
+        achieved_milestones = set[t.Any](data.get("milestones_achieved", []))
         return [
             milestone
             for milestone in self.MILESTONES
@@ -233,7 +228,14 @@ class CoverageRatchetService:
 
         return result
 
-    def get_status_report(self) -> dict[str, t.Any]:
+    def get_coverage_improvement_needed(self) -> float:
+        """Get percentage improvement needed to reach next milestone."""
+        current = self.get_baseline_coverage()
+        for milestone in self.MILESTONES:
+            if current < milestone:
+                needed = milestone - current
+                return max(0.0, needed)
+        return 0.0
         data = self.get_ratchet_data()
         if not data:
             return {"status": "not_initialized"}

crackerjack/services/debug.py

@@ -24,13 +24,13 @@ class AIAgentDebugger:
         self.logger = get_logger("crackerjack.ai_agent.debug")
         self.session_id = f"debug_{int(time.time())}"
 
+        self.debug_log_path: Path | None = None
+
         if self.enabled:
             log_manager = get_log_manager()
             self.debug_log_path = log_manager.create_debug_log_file(
                 f"ai-agent -{self.session_id}",
             )
-        else:
-            self.debug_log_path = None
 
         self.mcp_operations: list[dict[str, Any]] = []
         self.agent_activities: list[dict[str, Any]] = []
@@ -400,7 +400,7 @@ class AIAgentDebugger:
         self.console.print(table)
 
     def _print_agent_activity_breakdown(self, border_style: str = "red") -> None:
-        agent_stats = {}
+        agent_stats: dict[str, dict[str, t.Any]] = {}
         for activity in self.agent_activities:
             agent = activity["agent"]
             if agent not in agent_stats: