crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/agents/coordinator.py

@@ -1,8 +1,11 @@
 import asyncio
+import hashlib
 import logging
 import typing as t
 from collections import defaultdict
+from itertools import starmap
 
+from crackerjack.services.cache import CrackerjackCache
 from crackerjack.services.debug import get_ai_agent_debugger
 
 from .base import (
@@ -15,9 +18,29 @@ from .base import (
 )
 from .tracker import get_agent_tracker
 
+# Static mapping for O(1) agent lookup by issue type
+ISSUE_TYPE_TO_AGENTS = {
+    IssueType.COMPLEXITY: ["RefactoringAgent"],
+    IssueType.DEAD_CODE: ["RefactoringAgent", "ImportOptimizationAgent"],
+    IssueType.SECURITY: ["SecurityAgent"],
+    IssueType.PERFORMANCE: ["PerformanceAgent", "RefactoringAgent"],
+    IssueType.TEST_FAILURE: ["TestCreationAgent", "TestSpecialistAgent"],
+    IssueType.TYPE_ERROR: ["TestCreationAgent", "RefactoringAgent"],
+    IssueType.FORMATTING: ["FormattingAgent", "ImportOptimizationAgent"],
+    IssueType.DOCUMENTATION: ["DocumentationAgent"],
+    IssueType.DRY_VIOLATION: ["DRYAgent", "RefactoringAgent"],
+    IssueType.IMPORT_ERROR: ["ImportOptimizationAgent", "RefactoringAgent"],
+    IssueType.COVERAGE_IMPROVEMENT: ["TestCreationAgent", "TestSpecialistAgent"],
+    IssueType.TEST_ORGANIZATION: ["TestSpecialistAgent", "TestCreationAgent"],
+    IssueType.DEPENDENCY: ["RefactoringAgent"],
+    IssueType.REGEX_VALIDATION: ["SecurityAgent", "RefactoringAgent"],
+}
+
 
 class AgentCoordinator:
-    def __init__(self, context: AgentContext) -> None:
+    def __init__(
+        self, context: AgentContext, cache: CrackerjackCache | None = None
+    ) -> None:
         self.context = context
         self.agents: list[SubAgent] = []
         self.logger = logging.getLogger(__name__)
@@ -26,6 +49,7 @@ class AgentCoordinator:
         self.tracker = get_agent_tracker()
         self.debugger = get_ai_agent_debugger()
         self.proactive_mode = True
+        self.cache = cache or CrackerjackCache()
 
     def initialize_agents(self) -> None:
         self.agents = agent_registry.create_all(self.context)
@@ -52,15 +76,25 @@ class AgentCoordinator:
 
         issues_by_type = self._group_issues_by_type(issues)
 
-        overall_result = FixResult(success=True, confidence=1.0)
+        # Optimization: Run ALL issue types in parallel instead of sequential
+        tasks = list[t.Any](
+            starmap(self._handle_issues_by_type, issues_by_type.items())
+        )
 
-        for issue_type, type_issues in issues_by_type.items():
-            type_result = await self._handle_issues_by_type(issue_type, type_issues)
-            overall_result = overall_result.merge_with(type_result)
+        results = await asyncio.gather(*tasks, return_exceptions=True)
 
-        return overall_result
+        overall_result = FixResult(success=True, confidence=1.0)
+        for result in results:
+            if isinstance(result, FixResult):
+                overall_result = overall_result.merge_with(result)
+            else:
+                self.logger.error(f"Issue type handling failed: {result}")
+                overall_result.success = False
+                overall_result.remaining_issues.append(
+                    f"Type handling failed: {result}"
+                )
 
-    # Removed unused method: handle_single_issue
+        return overall_result
 
     async def _handle_issues_by_type(
         self,
@@ -69,10 +103,25 @@ class AgentCoordinator:
     ) -> FixResult:
         self.logger.info(f"Handling {len(issues)} {issue_type.value} issues")
 
+        # Fast agent lookup using static mapping
+        preferred_agent_names = ISSUE_TYPE_TO_AGENTS.get(issue_type, [])
+        specialist_agents = []
+
+        # First, try to use agents from static mapping for O(1) lookup
         specialist_agents = [
-            agent for agent in self.agents if issue_type in agent.get_supported_types()
+            agent
+            for agent in self.agents
+            if agent.__class__.__name__ in preferred_agent_names
         ]
 
+        # Fallback: use traditional dynamic lookup if no static match
+        if not specialist_agents:
+            specialist_agents = [
+                agent
+                for agent in self.agents
+                if issue_type in agent.get_supported_types()
+            ]
+
         if not specialist_agents:
             self.logger.warning(f"No specialist agents for {issue_type.value}")
             return FixResult(
@@ -109,20 +158,112 @@ class AgentCoordinator:
         specialists: list[SubAgent],
         issue: Issue,
     ) -> SubAgent | None:
-        best_agent = None
-        best_score = 0.0
+        candidates = await self._score_all_specialists(specialists, issue)
+        if not candidates:
+            return None
+
+        best_agent, best_score = self._find_highest_scoring_agent(candidates)
+        return self._apply_built_in_preference(candidates, best_agent, best_score)
+
+    async def _score_all_specialists(
+        self, specialists: list[SubAgent], issue: Issue
+    ) -> list[tuple[SubAgent, float]]:
+        """Score all specialist agents for handling an issue."""
+        candidates: list[tuple[SubAgent, float]] = []
 
         for agent in specialists:
             try:
                 score = await agent.can_handle(issue)
-                if score > best_score:
-                    best_score = score
-                    best_agent = agent
+                candidates.append((agent, score))
             except Exception as e:
                 self.logger.exception(f"Error evaluating specialist {agent.name}: {e}")
 
+        return candidates
+
+    def _find_highest_scoring_agent(
+        self, candidates: list[tuple[SubAgent, float]]
+    ) -> tuple[SubAgent | None, float]:
+        """Find the agent with the highest score."""
+        best_agent = None
+        best_score = 0.0
+
+        for agent, score in candidates:
+            if score > best_score:
+                best_score = score
+                best_agent = agent
+
+        return best_agent, best_score
+
+    def _apply_built_in_preference(
+        self,
+        candidates: list[tuple[SubAgent, float]],
+        best_agent: SubAgent | None,
+        best_score: float,
+    ) -> SubAgent | None:
+        """Apply preference for built-in agents when scores are close."""
+        if not best_agent or best_score <= 0:
+            return best_agent
+
+        # Threshold for considering scores "close" (5% difference)
+        CLOSE_SCORE_THRESHOLD = 0.05
+
+        for agent, score in candidates:
+            if self._should_prefer_built_in_agent(
+                agent, best_agent, score, best_score, CLOSE_SCORE_THRESHOLD
+            ):
+                self._log_built_in_preference(
+                    agent, score, best_agent, best_score, best_score - score
+                )
+                return agent
+
         return best_agent
 
+    def _should_prefer_built_in_agent(
+        self,
+        agent: SubAgent,
+        best_agent: SubAgent,
+        score: float,
+        best_score: float,
+        threshold: float,
+    ) -> bool:
+        """Check if a built-in agent should be preferred over the current best."""
+        return (
+            agent != best_agent
+            and self._is_built_in_agent(agent)
+            and 0 < (best_score - score) <= threshold
+        )
+
+    def _log_built_in_preference(
+        self,
+        agent: SubAgent,
+        score: float,
+        best_agent: SubAgent,
+        best_score: float,
+        score_difference: float,
+    ) -> None:
+        """Log when preferring a built-in agent."""
+        self.logger.info(
+            f"Preferring built-in agent {agent.name} (score: {score:.2f}) "
+            f"over {best_agent.name} (score: {best_score:.2f}) "
+            f"due to {score_difference:.2f} threshold preference"
+        )
+
+    def _is_built_in_agent(self, agent: SubAgent) -> bool:
+        """Check if agent is a built-in Crackerjack agent."""
+        built_in_agent_names = {
+            "ArchitectAgent",
+            "DocumentationAgent",
+            "DRYAgent",
+            "FormattingAgent",
+            "ImportOptimizationAgent",
+            "PerformanceAgent",
+            "RefactoringAgent",
+            "SecurityAgent",
+            "TestCreationAgent",
+            "TestSpecialistAgent",
+        }
+        return agent.__class__.__name__ in built_in_agent_names
+
     async def _handle_with_single_agent(
         self,
         agent: SubAgent,
@@ -130,6 +271,16 @@ class AgentCoordinator:
     ) -> FixResult:
         self.logger.info(f"Handling issue with {agent.name}: {issue.message[:100]}")
 
+        # Create cache key from issue content
+        issue_hash = self._create_issue_hash(issue)
+
+        # Check cache for previous agent decision
+        cached_decision = self.cache.get_agent_decision(agent.name, issue_hash)
+        if cached_decision:
+            self.logger.debug(f"Using cached decision for {agent.name}")
+            self.tracker.track_agent_complete(agent.name, cached_decision)
+            return cached_decision  # type: ignore[no-any-return]
+
         confidence = await agent.can_handle(issue)
         self.tracker.track_agent_processing(agent.name, issue, confidence)
 
@@ -142,7 +293,8 @@ class AgentCoordinator:
         )
 
         try:
-            result = await agent.analyze_and_fix(issue)
+            # Use cached analysis for better performance
+            result = await self._cached_analyze_and_fix(agent, issue)
             if result.success:
                 self.logger.info(f"{agent.name} successfully fixed issue")
             else:
@@ -183,6 +335,49 @@ class AgentCoordinator:
             grouped[issue.type].append(issue)
         return dict(grouped)
 
+    def _create_issue_hash(self, issue: Issue) -> str:
+        """Create a hash from issue content for caching decisions."""
+        content = (
+            f"{issue.type.value}:{issue.message}:{issue.file_path}:{issue.line_number}"
+        )
+        return hashlib.md5(content.encode(), usedforsecurity=False).hexdigest()
+
+    def _get_cache_key(self, agent_name: str, issue: Issue) -> str:
+        """Get cache key for agent-issue combination."""
+        issue_hash = self._create_issue_hash(issue)
+        return f"{agent_name}:{issue_hash}"
+
+    async def _cached_analyze_and_fix(self, agent: SubAgent, issue: Issue) -> FixResult:
+        """Analyze and fix issue with intelligent caching."""
+        cache_key = self._get_cache_key(agent.name, issue)
+
+        # Check in-memory cache first (fastest)
+        if cache_key in self._issue_cache:
+            self.logger.debug(f"Using in-memory cache for {agent.name}")
+            return self._issue_cache[cache_key]
+
+        # Check persistent cache
+        cached_result = self.cache.get_agent_decision(
+            agent.name, self._create_issue_hash(issue)
+        )
+        if cached_result:
+            self.logger.debug(f"Using persistent cache for {agent.name}")
+            # Store in memory cache for even faster future access
+            self._issue_cache[cache_key] = cached_result
+            return cached_result  # type: ignore[no-any-return]
+
+        # No cache hit - perform actual analysis
+        result = await agent.analyze_and_fix(issue)
+
+        # Cache successful results with high confidence
+        if result.success and result.confidence > 0.7:
+            self._issue_cache[cache_key] = result
+            self.cache.set_agent_decision(
+                agent.name, self._create_issue_hash(issue), result
+            )
+
+        return result
+
     def get_agent_capabilities(self) -> dict[str, dict[str, t.Any]]:
         if not self.agents:
             self.initialize_agents()
@@ -221,36 +416,59 @@ class AgentCoordinator:
         architect = self._get_architect_agent()
 
         if not architect:
-            self.logger.warning("No ArchitectAgent available for planning")
-            return {"strategy": "reactive_fallback", "patterns": []}
-
-        complex_issues = [
-            issue
-            for issue in issues
-            if issue.type
-            in {IssueType.COMPLEXITY, IssueType.DRY_VIOLATION, IssueType.PERFORMANCE}
-        ]
+            return self._create_fallback_plan(
+                "No ArchitectAgent available for planning"
+            )
 
+        complex_issues = self._filter_complex_issues(issues)
         if not complex_issues:
             return {"strategy": "simple_fixes", "patterns": ["standard_patterns"]}
 
+        return await self._generate_architectural_plan(
+            architect, complex_issues, issues
+        )
+
+    def _create_fallback_plan(self, reason: str) -> dict[str, t.Any]:
+        """Create a fallback plan when architectural planning fails."""
+        self.logger.warning(reason)
+        return {"strategy": "reactive_fallback", "patterns": []}
+
+    def _filter_complex_issues(self, issues: list[Issue]) -> list[Issue]:
+        """Filter issues that require architectural planning."""
+        complex_types = {
+            IssueType.COMPLEXITY,
+            IssueType.DRY_VIOLATION,
+            IssueType.PERFORMANCE,
+        }
+        return [issue for issue in issues if issue.type in complex_types]
+
+    async def _generate_architectural_plan(
+        self, architect: t.Any, complex_issues: list[Issue], all_issues: list[Issue]
+    ) -> dict[str, t.Any]:
+        """Generate architectural plan using the architect agent."""
         primary_issue = complex_issues[0]
 
         try:
             plan = await architect.plan_before_action(primary_issue)
-
-            plan["all_issues"] = [issue.id for issue in issues]
-            plan["issue_types"] = list({issue.type.value for issue in issues})
+            plan = self._enrich_architectural_plan(plan, all_issues)
 
             self.logger.info(
                 f"Created architectural plan: {plan.get('strategy', 'unknown')}"
             )
-            return plan
+            return plan  # type: ignore[no-any-return]
 
         except Exception as e:
             self.logger.exception(f"Failed to create architectural plan: {e}")
             return {"strategy": "reactive_fallback", "patterns": [], "error": str(e)}
 
+    def _enrich_architectural_plan(
+        self, plan: dict[str, t.Any], issues: list[Issue]
+    ) -> dict[str, t.Any]:
+        """Enrich the architectural plan with issue metadata."""
+        plan["all_issues"] = [issue.id for issue in issues]
+        plan["issue_types"] = list[t.Any]({issue.type.value for issue in issues})
+        return plan
+
     async def _apply_fixes_with_plan(
         self, issues: list[Issue], plan: dict[str, t.Any]
     ) -> FixResult:
@@ -260,23 +478,43 @@ class AgentCoordinator:
             return await self.handle_issues(issues)
 
         self.logger.info(f"Applying fixes with {strategy} strategy")
-
         prioritized_issues = self._prioritize_issues_by_plan(issues, plan)
 
+        return await self._process_prioritized_groups(prioritized_issues, plan)
+
+    async def _process_prioritized_groups(
+        self, prioritized_issues: list[list[Issue]], plan: dict[str, t.Any]
+    ) -> FixResult:
+        """Process prioritized issue groups according to the plan."""
         overall_result = FixResult(success=True, confidence=1.0)
 
         for issue_group in prioritized_issues:
             group_result = await self._handle_issue_group_with_plan(issue_group, plan)
             overall_result = overall_result.merge_with(group_result)
 
-            if not group_result.success and self._is_critical_group(issue_group, plan):
-                overall_result.success = False
-                overall_result.remaining_issues.append(
-                    f"Critical issue group failed: {[i.id for i in issue_group]}"
+            if self._should_fail_on_group_failure(group_result, issue_group, plan):
+                overall_result = self._mark_critical_group_failure(
+                    overall_result, issue_group
                 )
 
         return overall_result
 
+    def _should_fail_on_group_failure(
+        self, group_result: FixResult, issue_group: list[Issue], plan: dict[str, t.Any]
+    ) -> bool:
+        """Determine if overall process should fail when a group fails."""
+        return not group_result.success and self._is_critical_group(issue_group, plan)
+
+    def _mark_critical_group_failure(
+        self, overall_result: FixResult, issue_group: list[Issue]
+    ) -> FixResult:
+        """Mark overall result as failed due to critical group failure."""
+        overall_result.success = False
+        overall_result.remaining_issues.append(
+            f"Critical issue group failed: {[i.id for i in issue_group]}"
+        )
+        return overall_result
+
     async def _validate_against_plan(
         self, result: FixResult, plan: dict[str, t.Any]
     ) -> FixResult:
@@ -318,7 +556,7 @@ class AgentCoordinator:
             return [complex_issues, other_issues] if complex_issues else [other_issues]
 
         groups = self._group_issues_by_type(issues)
-        return list(groups.values())
+        return list[t.Any](groups.values())
 
     async def _handle_issue_group_with_plan(
         self, issues: list[Issue], plan: dict[str, t.Any]

crackerjack/agents/documentation_agent.py

@@ -94,7 +94,9 @@ class DocumentationAgent(SubAgent):
     async def _fix_documentation_consistency(self, issue: Issue) -> FixResult:
         self.log("Checking documentation consistency")
 
-        md_files = list(Path().glob("*.md")) + list(Path("docs").glob("*.md"))
+        md_files = list[t.Any](Path().glob("*.md")) + list[t.Any](
+            Path("docs").glob("*.md")
+        )
 
         agent_count_issues = self._check_agent_count_consistency(md_files)
 
@@ -215,7 +217,7 @@ class DocumentationAgent(SubAgent):
 
     def _get_commit_messages(self, commit_range: str) -> str:
         result = subprocess.run(
-            ["git", "log", commit_range, "--pretty=format:%s|%h|%an"],
+            ["git", "log", commit_range, "--pretty=format: %s|%h|%an"],
             capture_output=True,
             text=True,
             check=False,
@@ -267,11 +269,11 @@ class DocumentationAgent(SubAgent):
         return categories
 
     def _get_change_category(self, message: str) -> str:
-        if message.startswith(("feat:", "feature:")):
+        if message.startswith(("feat: ", "feature: ")):
             return "features"
-        if message.startswith("fix:"):
+        if message.startswith("fix: "):
             return "fixes"
-        if message.startswith(("refactor:", "refact:")):
+        if message.startswith(("refactor: ", "refact: ")):
             return "refactors"
         return "other"
 
@@ -323,8 +325,8 @@ class DocumentationAgent(SubAgent):
 
 All notable changes to this project will be documented in this file.
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+The format is based on [Keep a Changelog](https: //keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https: //semver.org/spec/v2.0.0.html).
 
 {entry}
 """
@@ -376,7 +378,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
         patterns: list[str],
         expected_count: int,
     ) -> tuple[Path, int, int] | None:
-        """Analyze file content for agent count inconsistencies."""
         pattern_map = self._get_safe_pattern_map()
 
         for pattern in patterns:
@@ -389,7 +390,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
         return None
 
     def _get_safe_pattern_map(self) -> dict[str, str]:
-        """Get mapping of pattern strings to SAFE_PATTERNS keys."""
         return {
             SAFE_PATTERNS["agent_count_pattern"].pattern: "agent_count_pattern",
             SAFE_PATTERNS[
@@ -409,7 +409,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
         file_path: Path,
         expected_count: int,
     ) -> tuple[Path, int, int] | None:
-        """Check a specific pattern for count mismatches."""
         if pattern not in pattern_map:
             return None
 
@@ -428,7 +427,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
         file_path: Path,
         expected_count: int,
     ) -> tuple[Path, int, int] | None:
-        """Find count mismatches in pattern matches."""
         matches = safe_pattern.findall(content)
 
         for match in matches:
@@ -439,7 +437,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
         return None
 
     def _is_count_mismatch(self, count: int, expected_count: int) -> bool:
-        """Check if count represents a mismatch worth reporting."""
         return count != expected_count and count > 4
 
     def _fix_agent_count_references(
@@ -448,16 +445,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
         current_count: int,
         expected_count: int,
     ) -> str:
-        # Use SAFE_PATTERNS with dynamic replacement
         updated_content = content
 
-        # Replace agent count references using safe patterns
         agent_pattern = SAFE_PATTERNS["update_agent_count"]
         specialized_pattern = SAFE_PATTERNS["update_specialized_agent_count"]
         config_pattern = SAFE_PATTERNS["update_total_agents_config"]
         sub_agent_pattern = SAFE_PATTERNS["update_sub_agent_count"]
 
-        # Apply patterns with dynamic replacement (NEW_COUNT -> expected_count)
         updated_content = agent_pattern.apply(updated_content).replace(
             "NEW_COUNT", str(expected_count)
         )

crackerjack/agents/dry_agent.py

@@ -152,8 +152,6 @@ class DRYAgent(SubAgent):
         error_responses: list[dict[str, t.Any]] = []
         for i, line in enumerate(lines):
             if error_pattern.test(line.strip()):
-                # Extract error message using the pattern's compiled regex access
-                # Access the compiled pattern from SAFE_PATTERNS to get groups
                 compiled_pattern = error_pattern._get_compiled_pattern()
                 match = compiled_pattern.search(line.strip())
                 if match:
@@ -274,7 +272,6 @@ class DRYAgent(SubAgent):
     def _apply_violation_fix(
         self, lines: list[str], violation: dict[str, t.Any]
     ) -> tuple[list[str], bool]:
-        """Apply fix for a specific violation type."""
         violation_type = violation["type"]
 
         if violation_type == "error_response_pattern":
@@ -289,16 +286,13 @@ class DRYAgent(SubAgent):
         lines: list[str],
         violation: dict[str, t.Any],
     ) -> tuple[list[str], bool]:
-        # Add utility functions to the file
         utility_lines = self._add_error_response_utilities(lines)
 
-        # Apply pattern replacements to affected lines
         self._apply_error_pattern_replacements(lines, violation, len(utility_lines))
 
         return lines, True
 
     def _add_error_response_utilities(self, lines: list[str]) -> list[str]:
-        """Add utility functions for error responses and path conversion."""
         utility_function = """
 def _create_error_response(message: str, success: bool = False) -> str:
 
@@ -319,7 +313,6 @@ def _ensure_path(path: str | Path) -> Path:
         return [line for line in utility_lines]
 
     def _find_utility_insert_position(self, lines: list[str]) -> int:
-        """Find the best position to insert utility functions."""
         insert_pos = 0
         for i, line in enumerate(lines):
             if line.strip().startswith(("import ", "from ")):
@@ -331,7 +324,6 @@ def _ensure_path(path: str | Path) -> Path:
     def _apply_error_pattern_replacements(
         self, lines: list[str], violation: dict[str, t.Any], utility_lines_count: int
     ) -> None:
-        """Apply pattern replacements to lines with error response patterns."""
         path_pattern = SAFE_PATTERNS["fix_path_conversion_with_ensure_path"]
 
         for instance in violation["instances"]:
@@ -348,7 +340,6 @@ def _ensure_path(path: str | Path) -> Path:
         lines: list[str],
         violation: dict[str, t.Any],
     ) -> tuple[list[str], bool]:
-        """Fix path conversion patterns by adding utility function."""
         utility_function_added = self._check_ensure_path_exists(lines)
         adjustment = 0
 
@@ -362,20 +353,18 @@ def _ensure_path(path: str | Path) -> Path:
         return lines, modified
 
     def _check_ensure_path_exists(self, lines: list[str]) -> bool:
-        """Check if _ensure_path utility function already exists."""
         return any(
             "_ensure_path" in line and "def _ensure_path" in line for line in lines
         )
 
     def _add_ensure_path_utility(self, lines: list[str]) -> int:
-        """Add the _ensure_path utility function and return adjustment count."""
         insert_pos = self._find_utility_insert_position(lines)
 
         utility_lines = [
             "",
-            "def _ensure_path(path: str | Path) -> Path:",
-            '    """Convert string path to Path object if needed."""',
-            "    return Path(path) if isinstance(path, str) else path",
+            "def _ensure_path(path: str | Path) -> Path: ",
+            ' """Convert string path to Path object if needed."""',
+            " return Path(path) if isinstance(path, str) else path",
             "",
         ]
 
@@ -391,7 +380,6 @@ def _ensure_path(path: str | Path) -> Path:
         adjustment: int,
         utility_function_added: bool,
     ) -> bool:
-        """Replace path conversion patterns with utility function calls."""
         path_pattern = SAFE_PATTERNS["fix_path_conversion_simple"]
 
         modified = False

crackerjack/agents/formatting_agent.py

@@ -173,7 +173,7 @@ class FormattingAgent(SubAgent):
                 "check",
                 ".",
                 "--select",
-                "I,F401",
+                "I, F401",
                 "--fix",
             ],
         )