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

crackerjack/services/pattern_detector.py

@@ -1,16 +1,24 @@
 import ast
 import logging
+import typing as t
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from pathlib import Path
 
 from ..agents.base import Issue, IssueType, Priority
 from .pattern_cache import CachedPattern, PatternCache
 
+DetectorMethod = Callable[[Path, str, ast.AST], Awaitable[list["AntiPattern"]]]
+
+
+class AntiPatternConfig(t.TypedDict):
+    detector: DetectorMethod
+    description: str
+    prevention: str
+
 
 @dataclass
 class AntiPattern:
-    """Detected anti-pattern that could lead to issues."""
-
     pattern_type: str
     severity: Priority
     file_path: str
@@ -21,19 +29,12 @@ class AntiPattern:
 
 
 class PatternDetector:
-    """Detects anti-patterns and suggests proactive refactoring.
-
-    Analyzes code to identify patterns that commonly lead to quality
-    violations, allowing proactive fixes before issues occur.
-    """
-
     def __init__(self, project_path: Path, pattern_cache: PatternCache) -> None:
         self.project_path = project_path
         self.pattern_cache = pattern_cache
         self.logger = logging.getLogger(__name__)
 
-        # Known anti-patterns and their detection rules
-        self._anti_patterns = {
+        self._anti_patterns: dict[str, AntiPatternConfig] = {
             "complexity_hotspot": {
                 "detector": self._detect_complexity_hotspots,
                 "description": "Functions approaching complexity limits",
@@ -62,14 +63,12 @@ class PatternDetector:
         }
 
     async def analyze_codebase(self) -> list[AntiPattern]:
-        """Analyze the entire codebase for anti-patterns."""
         self.logger.info("Starting proactive anti-pattern analysis")
 
         anti_patterns = []
         python_files = list(self.project_path.glob("**/*.py"))
 
         for file_path in python_files:
-            # Skip files in common ignore patterns
             if self._should_skip_file(file_path):
                 continue
 
@@ -80,25 +79,21 @@ class PatternDetector:
         return anti_patterns
 
     async def _analyze_file(self, file_path: Path) -> list[AntiPattern]:
-        """Analyze a single file for anti-patterns."""
         anti_patterns = []
 
         try:
             content = file_path.read_text(encoding="utf-8")
 
-            # Parse AST for analysis
             try:
                 tree = ast.parse(content, filename=str(file_path))
             except SyntaxError as e:
-                # File has syntax errors, skip analysis
                 self.logger.warning(f"Syntax error in {file_path}: {e}")
                 return []
 
-            # Run all anti-pattern detectors
             for pattern_name, pattern_info in self._anti_patterns.items():
-                detector = pattern_info["detector"]
+                detector_method = pattern_info["detector"]
                 try:
-                    detected = await detector(file_path, content, tree)  # type: ignore[operator]
+                    detected = await detector_method(file_path, content, tree)
                     anti_patterns.extend(detected)
                 except Exception as e:
                     self.logger.warning(
@@ -113,18 +108,14 @@ class PatternDetector:
     async def _detect_complexity_hotspots(
         self, file_path: Path, content: str, tree: ast.AST
     ) -> list[AntiPattern]:
-        """Detect functions that are approaching complexity limits."""
         anti_patterns = []
 
         class ComplexityVisitor(ast.NodeVisitor):
             def __init__(self) -> None:
-                self.functions: list[
-                    tuple[str, int, int]
-                ] = []  # name, line, complexity_estimate
+                self.functions: list[tuple[str, int, int]] = []
 
             def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
-                # Simple complexity estimation based on control structures
-                complexity = 1  # Base complexity
+                complexity = 1
 
                 for child in ast.walk(node):
                     if isinstance(child, ast.If | ast.For | ast.While | ast.With):
@@ -142,16 +133,15 @@ class PatternDetector:
         visitor = ComplexityVisitor()
         visitor.visit(tree)
 
-        # Flag functions approaching the complexity limit (13)
         for func_name, line_no, complexity in visitor.functions:
-            if complexity >= 10:  # Warn before hitting the limit
+            if complexity >= 10:
                 anti_patterns.append(
                     AntiPattern(
                         pattern_type="complexity_hotspot",
                         severity=Priority.HIGH if complexity >= 12 else Priority.MEDIUM,
                         file_path=str(file_path),
                         line_number=line_no,
-                        description=f"Function '{func_name}' has complexity {complexity} (approaching limit of 13)",
+                        description=f"Function '{func_name}' has complexity {complexity} (approaching limit of 15)",
                         suggestion=f"Break down '{func_name}' into smaller helper methods",
                         prevention_strategy="extract_method",
                     )
@@ -162,10 +152,8 @@ class PatternDetector:
     async def _detect_code_duplication(
         self, file_path: Path, content: str, tree: ast.AST
     ) -> list[AntiPattern]:
-        """Detect potential code duplication patterns."""
         anti_patterns = []
 
-        # Simple heuristic: look for repeated string literals or similar patterns
         lines = content.split("\n")
         line_groups = {}
 
@@ -177,9 +165,8 @@ class PatternDetector:
                 else:
                     line_groups[stripped] = [i]
 
-        # Flag lines that appear multiple times
         for line_content, line_numbers in line_groups.items():
-            if len(line_numbers) >= 3:  # Appears 3+ times
+            if len(line_numbers) >= 3:
                 anti_patterns.append(
                     AntiPattern(
                         pattern_type="code_duplication",
@@ -197,29 +184,24 @@ class PatternDetector:
     async def _detect_performance_issues(
         self, file_path: Path, content: str, tree: ast.AST
     ) -> list[AntiPattern]:
-        """Detect potential performance anti-patterns."""
         anti_patterns = []
 
         class PerformanceVisitor(ast.NodeVisitor):
             def __init__(self) -> None:
-                self.issues: list[
-                    tuple[int, str, str]
-                ] = []  # line, description, suggestion
+                self.issues: list[tuple[int, str, str]] = []
 
             def visit_For(self, node: ast.For) -> None:
-                # Check for nested loops (potential O(n²))
                 for child in ast.walk(node.body[0] if node.body else node):
                     if isinstance(child, ast.For | ast.While) and child != node:
                         self.issues.append(
                             (
                                 node.lineno,
-                                "Nested loop detected - potential O(n²) complexity",
+                                "Nested loop detected-potential O(n²) complexity",
                                 "Consider using dictionary lookups or set operations",
                             )
                         )
                         break
 
-                # Check for list concatenation in loops
                 for stmt in node.body:
                     if (
                         isinstance(stmt, ast.AugAssign)
@@ -229,7 +211,7 @@ class PatternDetector:
                         self.issues.append(
                             (
                                 stmt.lineno,
-                                "List concatenation in loop - inefficient",
+                                "List concatenation in loop-inefficient",
                                 "Use list.append() and join at the end",
                             )
                         )
@@ -257,14 +239,11 @@ class PatternDetector:
     async def _detect_security_risks(
         self, file_path: Path, content: str, tree: ast.AST
     ) -> list[AntiPattern]:
-        """Detect potential security anti-patterns."""
         anti_patterns = []
 
-        # Check for hardcoded paths
         hardcoded_path_patterns = self._check_hardcoded_paths(file_path, content)
         anti_patterns.extend(hardcoded_path_patterns)
 
-        # Check for subprocess security issues
         subprocess_patterns = self._check_subprocess_security(file_path, tree)
         anti_patterns.extend(subprocess_patterns)
 
@@ -273,7 +252,6 @@ class PatternDetector:
     def _check_hardcoded_paths(
         self, file_path: Path, content: str
     ) -> list[AntiPattern]:
-        """Check for hardcoded paths (common security issue)."""
         anti_patterns = []
 
         if "/tmp/" in content or "C:\\" in content:  # nosec B108
@@ -286,7 +264,7 @@ class PatternDetector:
                             severity=Priority.HIGH,
                             file_path=str(file_path),
                             line_number=i,
-                            description="Hardcoded path detected - potential security risk",
+                            description="Hardcoded path detected-potential security risk",
                             suggestion="Use tempfile module for temporary files",
                             prevention_strategy="use_secure_temp_files",
                         )
@@ -298,7 +276,6 @@ class PatternDetector:
     def _check_subprocess_security(
         self, file_path: Path, tree: ast.AST
     ) -> list[AntiPattern]:
-        """Check for shell=True in subprocess calls."""
         anti_patterns = []
 
         class SecurityVisitor(ast.NodeVisitor):
@@ -306,7 +283,6 @@ class PatternDetector:
                 self.issues: list[tuple[int, str, str]] = []
 
             def visit_Call(self, node: ast.Call) -> None:
-                # Check for subprocess with shell=True
                 if (
                     isinstance(node.func, ast.Attribute)
                     and isinstance(node.func.value, ast.Name)
@@ -321,7 +297,7 @@ class PatternDetector:
                             self.issues.append(
                                 (
                                     node.lineno,
-                                    "subprocess with shell=True - security risk",
+                                    "subprocess with shell=True-security risk",
                                     "Avoid shell=True or validate inputs carefully",
                                 )
                             )
@@ -349,7 +325,6 @@ class PatternDetector:
     async def _detect_import_complexity(
         self, file_path: Path, content: str, tree: ast.AST
     ) -> list[AntiPattern]:
-        """Detect complex or problematic import patterns."""
         anti_patterns = []
 
         class ImportVisitor(ast.NodeVisitor):
@@ -360,16 +335,14 @@ class PatternDetector:
             def visit_Import(self, node: ast.Import) -> None:
                 self.import_count += len(node.names)
                 for alias in node.names:
-                    if alias.name.count(".") > 2:  # Deep import
+                    if alias.name.count(".") > 2:
                         self.imports.append((node.lineno, f"Deep import: {alias.name}"))
                 self.generic_visit(node)
 
             def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
                 if node.module:
                     self.import_count += len(node.names) if node.names else 1
-                    if (
-                        node.names and len(node.names) > 10
-                    ):  # Many imports from one module
+                    if node.names and len(node.names) > 10:
                         self.imports.append(
                             (node.lineno, f"Many imports from {node.module}")
                         )
@@ -378,7 +351,6 @@ class PatternDetector:
         visitor = ImportVisitor()
         visitor.visit(tree)
 
-        # Flag files with excessive imports
         if visitor.import_count > 50:
             anti_patterns.append(
                 AntiPattern(
@@ -386,13 +358,12 @@ class PatternDetector:
                     severity=Priority.MEDIUM,
                     file_path=str(file_path),
                     line_number=1,
-                    description=f"File has {visitor.import_count} imports - may indicate tight coupling",
+                    description=f"File has {visitor.import_count} imports-may indicate tight coupling",
                     suggestion="Consider breaking file into smaller modules",
                     prevention_strategy="modular_design",
                 )
             )
 
-        # Flag specific problematic imports
         for line_no, description in visitor.imports:
             anti_patterns.append(
                 AntiPattern(
@@ -409,7 +380,6 @@ class PatternDetector:
         return anti_patterns
 
     def _should_skip_file(self, file_path: Path) -> bool:
-        """Check if file should be skipped in analysis."""
         skip_patterns = [
             "__pycache__",
             ".git",
@@ -428,11 +398,9 @@ class PatternDetector:
     async def suggest_proactive_refactoring(
         self, anti_patterns: list[AntiPattern]
     ) -> list[Issue]:
-        """Convert anti-patterns to proactive refactoring issues."""
         issues = []
 
         for anti_pattern in anti_patterns:
-            # Map anti-pattern types to issue types
             issue_type_map = {
                 "complexity_hotspot": IssueType.COMPLEXITY,
                 "code_duplication": IssueType.DRY_VIOLATION,
@@ -466,7 +434,6 @@ class PatternDetector:
     async def get_cached_solutions(
         self, anti_patterns: list[AntiPattern]
     ) -> dict[str, CachedPattern]:
-        """Get cached solutions for detected anti-patterns."""
         solutions = {}
 
         for anti_pattern in anti_patterns:
@@ -479,13 +446,11 @@ class PatternDetector:
         return solutions
 
     def _generate_solution_key(self, anti_pattern: AntiPattern) -> str:
-        """Generate unique key for anti-pattern solution."""
         return f"{anti_pattern.pattern_type}_{anti_pattern.file_path}_{anti_pattern.line_number}"
 
     def _find_cached_pattern_for_anti_pattern(
         self, anti_pattern: AntiPattern
     ) -> CachedPattern | None:
-        """Find cached pattern for a specific anti-pattern."""
         issue_type = self._map_anti_pattern_to_issue_type(anti_pattern.pattern_type)
         if not issue_type:
             return None
@@ -494,7 +459,6 @@ class PatternDetector:
         return self.pattern_cache.get_best_pattern_for_issue(temp_issue)
 
     def _map_anti_pattern_to_issue_type(self, pattern_type: str) -> IssueType | None:
-        """Map anti-pattern type to issue type."""
         return {
             "complexity_hotspot": IssueType.COMPLEXITY,
             "code_duplication": IssueType.DRY_VIOLATION,
@@ -505,7 +469,6 @@ class PatternDetector:
     def _create_temp_issue_for_lookup(
         self, anti_pattern: AntiPattern, issue_type: IssueType
     ) -> Issue:
-        """Create temporary issue for pattern cache lookup."""
         return Issue(
             id="temp",
             type=issue_type,

crackerjack/services/performance_benchmarks.py

@@ -55,9 +55,8 @@ class PerformanceBenchmarkService:
         run_hooks: bool = True,
         iterations: int = 1,
     ) -> PerformanceReport:
-        """Run comprehensive performance benchmark across all components."""
         self.console.print(
-            "[cyan]🚀 Starting comprehensive performance benchmark...[/cyan]",
+            "[cyan]🚀 Starting comprehensive performance benchmark...[/ cyan]",
         )
 
         start_time = time.time()
@@ -69,7 +68,6 @@ class PerformanceBenchmarkService:
         return report
 
     def _initialize_performance_report(self) -> PerformanceReport:
-        """Initialize a new performance report."""
         return PerformanceReport(total_duration=0.0)
 
     def _run_requested_benchmarks(
@@ -79,7 +77,6 @@ class PerformanceBenchmarkService:
         run_hooks: bool,
         iterations: int,
     ) -> None:
-        """Run the requested benchmark types."""
         if run_tests:
             report.test_benchmarks = self._benchmark_test_suite(iterations)
 
@@ -94,14 +91,13 @@ class PerformanceBenchmarkService:
         report: PerformanceReport,
         start_time: float,
     ) -> None:
-        """Finalize performance report with analysis and history."""
         report.total_duration = time.time() - start_time
         report.recommendations = self._generate_performance_recommendations(report)
         report.baseline_comparison = self._compare_with_baseline(report)
         self._save_performance_history(report)
 
     def _benchmark_test_suite(self, iterations: int = 1) -> dict[str, Any]:
-        self.console.print("[dim]📊 Benchmarking test suite...[/dim]")
+        self.console.print("[dim]📊 Benchmarking test suite...[/ dim]")
 
         benchmark_results = {}
 
@@ -152,7 +148,7 @@ class PerformanceBenchmarkService:
         return benchmark_results
 
     def _benchmark_hooks(self, iterations: int = 1) -> dict[str, float]:
-        self.console.print("[dim]🔧 Benchmarking hooks performance...[/dim]")
+        self.console.print("[dim]🔧 Benchmarking hooks performance...[/ dim]")
 
         hook_performance = {}
 
@@ -207,7 +203,7 @@ class PerformanceBenchmarkService:
         self,
         iterations: int = 1,
     ) -> list[BenchmarkResult]:
-        self.console.print("[dim]⚙️ Benchmarking workflow components...[/dim]")
+        self.console.print("[dim]⚙️ Benchmarking workflow components...[/ dim]")
 
         results = []
 
@@ -260,7 +256,6 @@ class PerformanceBenchmarkService:
         self,
         report: PerformanceReport,
     ) -> list[str]:
-        """Generate performance recommendations based on benchmark results."""
         recommendations = []
 
         self._add_test_suite_recommendations(report, recommendations)
@@ -275,19 +270,17 @@ class PerformanceBenchmarkService:
         report: PerformanceReport,
         recommendations: list[str],
     ) -> None:
-        """Add recommendations for test suite performance."""
         if not report.test_benchmarks:
             return
 
         for iteration_data in report.test_benchmarks.values():
             if self._is_slow_test_iteration(iteration_data):
                 recommendations.append(
-                    "Consider optimizing test suite - execution time exceeds 1 minute",
+                    "Consider optimizing test suite-execution time exceeds 1 minute",
                 )
                 break
 
     def _is_slow_test_iteration(self, iteration_data: Any) -> bool:
-        """Check if test iteration is slow."""
         return (
             isinstance(iteration_data, dict)
             and iteration_data.get("total_duration", 0) > 60
@@ -298,7 +291,6 @@ class PerformanceBenchmarkService:
         report: PerformanceReport,
         recommendations: list[str],
     ) -> None:
-        """Add recommendations for hook performance."""
         slow_hooks = self._identify_slow_hooks(report.hook_performance)
         if slow_hooks:
             recommendations.append(self._format_slow_hooks_message(slow_hooks))
@@ -307,7 +299,6 @@ class PerformanceBenchmarkService:
         self,
         hook_performance: dict[str, float],
     ) -> list[tuple[str, float]]:
-        """Identify hooks with slow performance."""
         slow_hooks = []
         for hook_name, perf_data in hook_performance.items():
             if isinstance(perf_data, dict):
@@ -317,8 +308,7 @@ class PerformanceBenchmarkService:
         return slow_hooks
 
     def _format_slow_hooks_message(self, slow_hooks: list[tuple[str, float]]) -> str:
-        """Format message for slow hooks recommendation."""
-        hooks_info = ", ".join(f"{h}({d:.1f}s)" for h, d in slow_hooks[:3])
+        hooks_info = ", ".join(f"{h}({d: .1f}s)" for h, d in slow_hooks[:3])
         return (
             f"Slow hooks detected: {hooks_info}. "
             "Consider hook optimization or selective execution."
@@ -329,7 +319,6 @@ class PerformanceBenchmarkService:
         report: PerformanceReport,
         recommendations: list[str],
     ) -> None:
-        """Add recommendations for component performance."""
         slow_components = self._identify_slow_components(report.workflow_benchmarks)
         if slow_components:
             components_names = ", ".join(c.name for c in slow_components)
@@ -342,7 +331,6 @@ class PerformanceBenchmarkService:
         self,
         workflow_benchmarks: list[BenchmarkResult],
     ) -> list[BenchmarkResult]:
-        """Identify slow workflow components."""
         return [b for b in workflow_benchmarks if b.duration_seconds > 5]
 
     def _add_overall_performance_recommendations(
@@ -350,7 +338,6 @@ class PerformanceBenchmarkService:
         report: PerformanceReport,
         recommendations: list[str],
     ) -> None:
-        """Add recommendations for overall performance."""
         if report.total_duration > 300:
             recommendations.append(
                 "Overall workflow execution is slow. Consider enabling --skip-hooks "
@@ -361,7 +348,6 @@ class PerformanceBenchmarkService:
         self,
         current_report: PerformanceReport,
     ) -> dict[str, float]:
-        """Compare current performance with historical baseline."""
         baseline_comparison = {}
 
         try:
@@ -386,7 +372,6 @@ class PerformanceBenchmarkService:
         return baseline_comparison
 
     def _load_performance_history(self) -> list[dict[str, Any]] | None:
-        """Load performance history from file."""
         if not self.history_file.exists():
             return None
 
@@ -401,7 +386,6 @@ class PerformanceBenchmarkService:
         history: list[dict[str, Any]],
         comparison: dict[str, Any],
     ) -> None:
-        """Add overall performance comparison to baseline."""
         recent_runs = history[-5:]
         baseline_duration = statistics.median(
             [r["total_duration"] for r in recent_runs],
@@ -418,7 +402,6 @@ class PerformanceBenchmarkService:
         history: list[dict[str, Any]],
         comparison: dict[str, Any],
     ) -> None:
-        """Add component-level performance comparison."""
         recent_runs = history[-5:]
         if not recent_runs:
             return
@@ -439,7 +422,6 @@ class PerformanceBenchmarkService:
         current_duration: float,
         old_duration: float,
     ) -> float:
-        """Calculate performance change percentage."""
         return ((current_duration - old_duration) / old_duration) * 100
 
     def _save_performance_history(self, report: PerformanceReport) -> None:
@@ -471,11 +453,13 @@ class PerformanceBenchmarkService:
 
         except Exception as e:
             self.console.print(
-                f"[yellow]⚠️[/yellow] Could not save performance history: {e}",
+                f"[yellow]⚠️[/ yellow] Could not save performance history: {e}",
             )
 
     def display_performance_report(self, report: PerformanceReport) -> None:
-        self.console.print("\n[bold cyan]🚀 Performance Benchmark Report[/bold cyan]\n")
+        self.console.print(
+            "\n[bold cyan]🚀 Performance Benchmark Report[/ bold cyan]\n"
+        )
 
         self._display_overall_stats(report)
         self._display_workflow_components(report)
@@ -484,12 +468,12 @@ class PerformanceBenchmarkService:
         self._display_recommendations(report)
 
         self.console.print(
-            f"\n[dim]📁 Benchmark data saved to: {self.benchmarks_dir}[/dim]",
+            f"\n[dim]📁 Benchmark data saved to: {self.benchmarks_dir}[/ dim]",
         )
 
     def _display_overall_stats(self, report: PerformanceReport) -> None:
         self.console.print(
-            f"[green]⏱️ Total Duration: {report.total_duration:.2f}s[/green]",
+            f"[green]⏱️ Total Duration: {report.total_duration: .2f}s[/ green]",
         )
 
     def _display_workflow_components(self, report: PerformanceReport) -> None:
@@ -505,7 +489,7 @@ class PerformanceBenchmarkService:
             metadata_str = ", ".join(f"{k}={v}" for k, v in benchmark.metadata.items())
             table.add_row(
                 benchmark.name,
-                f"{benchmark.duration_seconds:.3f}",
+                f"{benchmark.duration_seconds: .3f}",
                 metadata_str,
             )
 
@@ -526,9 +510,9 @@ class PerformanceBenchmarkService:
             if isinstance(perf_data, dict):
                 table.add_row(
                     hook_name,
-                    f"{perf_data.get('mean_duration', 0):.2f}",
-                    f"{perf_data.get('min_duration', 0):.2f}",
-                    f"{perf_data.get('max_duration', 0):.2f}",
+                    f"{perf_data.get('mean_duration', 0): .2f}",
+                    f"{perf_data.get('min_duration', 0): .2f}",
+                    f"{perf_data.get('max_duration', 0): .2f}",
                 )
 
         self.console.print(table)
@@ -543,31 +527,28 @@ class PerformanceBenchmarkService:
         self.console.print()
 
     def _print_comparison_header(self) -> None:
-        """Print performance comparison header."""
-        self.console.print("[bold]📊 Performance Comparison[/bold]")
+        self.console.print("[bold]📊 Performance Comparison[/ bold]")
 
     def _print_comparison_metrics(self, baseline_comparison: dict[str, t.Any]) -> None:
-        """Print individual comparison metrics with appropriate colors."""
         for metric, value in baseline_comparison.items():
             if isinstance(value, float | int) and "percent" in metric:
                 color = "green" if value < 0 else "red" if value > 10 else "yellow"
                 direction = "faster" if value < 0 else "slower"
                 self.console.print(
-                    f" {metric}: [{color}]{abs(value):.1f}% {direction}[/{color}]",
+                    f" {metric}: [{color}]{abs(value): .1f}% {direction}[/{color}]",
                 )
 
     def _display_recommendations(self, report: PerformanceReport) -> None:
         if report.recommendations:
             self.console.print(
-                "[bold yellow]💡 Performance Recommendations[/bold yellow]",
+                "[bold yellow]💡 Performance Recommendations[/ bold yellow]",
             )
             for i, rec in enumerate(report.recommendations, 1):
                 self.console.print(f" {i}. {rec}")
         else:
-            self.console.print("[green]✨ No performance issues detected![/green]")
+            self.console.print("[green]✨ No performance issues detected ![/ green]")
 
     def get_performance_trends(self, days: int = 7) -> dict[str, Any]:
-        """Get performance trends over specified time period."""
         try:
             recent_history = self._get_recent_history(days)
             if not recent_history:
@@ -584,7 +565,6 @@ class PerformanceBenchmarkService:
             return {"error": f"Could not analyze trends: {e}"}
 
     def _get_recent_history(self, days: int) -> list[dict[str, Any]] | None:
-        """Get recent performance history within specified days."""
         if not self.history_file.exists():
             return None
 
@@ -597,7 +577,6 @@ class PerformanceBenchmarkService:
         return recent_history if len(recent_history) >= 2 else None
 
     def _handle_insufficient_trend_data(self) -> dict[str, str]:
-        """Handle cases where insufficient data is available for trend analysis."""
         if not self.history_file.exists():
             return {"error": "No performance history available"}
         return {"error": "Insufficient data for trend analysis"}
@@ -605,7 +584,6 @@ class PerformanceBenchmarkService:
     def _add_duration_trends(
         self, recent_history: list[dict[str, Any]], trends: dict[str, Any]
     ) -> None:
-        """Add overall duration trends to results."""
         durations = [r["total_duration"] for r in recent_history]
         trends["duration_trend"] = {
             "current": durations[-1],
@@ -616,7 +594,6 @@ class PerformanceBenchmarkService:
     def _add_component_trends(
         self, recent_history: list[dict[str, Any]], trends: dict[str, Any]
     ) -> None:
-        """Add component-level trends to results."""
         component_trends = {}
         latest_components = recent_history[-1].get("component_durations", {})
 
@@ -639,7 +616,6 @@ class PerformanceBenchmarkService:
         recent_history: list[dict[str, Any]],
         component: str,
     ) -> list[float]:
-        """Extract duration data for a specific component."""
         return [
             r.get("component_durations", {}).get(component)
             for r in recent_history
@@ -647,7 +623,6 @@ class PerformanceBenchmarkService:
         ]
 
     def _determine_trend_direction(self, durations: list[float]) -> str:
-        """Determine if trend is improving or degrading."""
         current = durations[-1]
         historical_average = statistics.mean(durations[:-1])
         return "improving" if current < historical_average else "degrading"