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

crackerjack/agents/refactoring_helpers.py

@@ -1,12 +1,8 @@
-"""Refactoring analysis helper classes and utilities."""
-
 import ast
 import typing as t
 
 
 class ComplexityCalculator(ast.NodeVisitor):
-    """Calculator for cognitive complexity analysis."""
-
     def __init__(self) -> None:
         self.complexity = 0
         self.nesting_level = 0
@@ -43,36 +39,28 @@ class ComplexityCalculator(ast.NodeVisitor):
         self._process_comprehension(node)
 
     def _process_conditional_node(self, node: ast.If) -> None:
-        """Process if/elif nodes with condition complexity."""
-        # Base complexity + nesting penalty
         self.complexity += 1 + self.nesting_level
 
-        # Penalty for complex conditions
         if self._has_complex_condition(node.test):
             self.complexity += 1
 
         self._visit_with_nesting(node)
 
     def _process_loop_node(self, node: ast.For | ast.While) -> None:
-        """Process for/while loop nodes."""
         self.complexity += 1 + self.nesting_level
         self._visit_with_nesting(node)
 
     def _process_try_node(self, node: ast.Try) -> None:
-        """Process try/except nodes with handler penalty."""
-        # Base complexity for try + number of except handlers
         self.complexity += 1 + self.nesting_level + len(node.handlers)
         self._visit_with_nesting(node)
 
     def _process_context_node(self, node: ast.With) -> None:
-        """Process with/context manager nodes."""
         self.complexity += 1 + self.nesting_level
         self._visit_with_nesting(node)
 
     def _process_boolean_operation(self, node: ast.BoolOp) -> None:
-        """Process boolean operations with chain penalty."""
         penalty = len(node.values) - 1
-        if penalty > 2:  # Long chains are more complex
+        if penalty > 2:
             penalty += 1
         self.complexity += penalty
         self.generic_visit(node)
@@ -80,31 +68,26 @@ class ComplexityCalculator(ast.NodeVisitor):
     def _process_comprehension(
         self, node: ast.ListComp | ast.DictComp | ast.SetComp | ast.GeneratorExp
     ) -> None:
-        """Process comprehensions with condition penalty."""
         self.complexity += 1
-        # Check each generator for ifs conditions
+
         for generator in node.generators:
             if hasattr(generator, "ifs") and generator.ifs:
                 self.complexity += len(generator.ifs)
         self.generic_visit(node)
 
     def _visit_with_nesting(self, node: ast.AST) -> None:
-        """Visit a node with proper nesting level tracking."""
         self.nesting_level += 1
         self.generic_visit(node)
         self.nesting_level -= 1
 
     def _has_complex_condition(self, node: ast.expr) -> bool:
-        """Check if condition involves complex expressions."""
         return (isinstance(node, ast.BoolOp) and len(node.values) > 2) or isinstance(
             node, ast.Compare | ast.Call
         )
 
 
 class UsageDataCollector:
-    """Collector for usage data analysis."""
-
-    def __init__(self):
+    def __init__(self) -> None:
         self.defined_names: set[str] = set()
         self.used_names: set[str] = set()
         self.import_lines: list[tuple[int, str, str]] = []
@@ -113,7 +96,6 @@ class UsageDataCollector:
         self.unused_variables: list[dict[str, t.Any]] = []
 
     def get_results(self, analyzer: "EnhancedUsageAnalyzer") -> dict[str, t.Any]:
-        """Get collected usage data results."""
         return {
             "defined_names": self.defined_names,
             "used_names": self.used_names,
@@ -126,12 +108,10 @@ class UsageDataCollector:
 
 
 class EnhancedUsageAnalyzer(ast.NodeVisitor):
-    """Analyzer for enhanced usage data collection."""
-
-    def __init__(self, collector: UsageDataCollector):
-        self.scope_stack = [set()]  # Track variable scopes
-        self.class_methods = {}  # Track class method usage
-        self.function_calls = set()  # Track function calls
+    def __init__(self, collector: UsageDataCollector) -> None:
+        self.scope_stack: list[set[str]] = [set()]
+        self.class_methods: dict[str, list[str]] = {}
+        self.function_calls: set[str] = set()
         self.collector = collector
 
     def visit_Import(self, node: ast.Import) -> None:
@@ -165,21 +145,18 @@ class EnhancedUsageAnalyzer(ast.NodeVisitor):
         self._process_attribute_access(node)
 
     def _process_import_node(self, node: ast.Import) -> None:
-        """Process import statements."""
         for alias in node.names:
             name = alias.asname or alias.name
             self.collector.defined_names.add(name)
             self.collector.import_lines.append((node.lineno, name, "import"))
 
     def _process_import_from_node(self, node: ast.ImportFrom) -> None:
-        """Process from-import statements."""
         for alias in node.names:
             name = alias.asname or alias.name
             self.collector.defined_names.add(name)
             self.collector.import_lines.append((node.lineno, name, "from_import"))
 
     def _process_function_definition(self, node: ast.FunctionDef) -> None:
-        """Process function definitions."""
         self.collector.defined_names.add(node.name)
         if self._should_track_function(node.name):
             function_info = self._create_function_info(node)
@@ -187,7 +164,6 @@ class EnhancedUsageAnalyzer(ast.NodeVisitor):
         self._visit_with_scope(node)
 
     def _process_async_function_definition(self, node: ast.AsyncFunctionDef) -> None:
-        """Process async function definitions."""
         self.collector.defined_names.add(node.name)
         if not node.name.startswith("_"):
             function_info = self._create_function_info(node)
@@ -195,7 +171,6 @@ class EnhancedUsageAnalyzer(ast.NodeVisitor):
         self._visit_with_scope(node)
 
     def _process_class_definition(self, node: ast.ClassDef) -> None:
-        """Process class definitions."""
         self.collector.defined_names.add(node.name)
         self.collector.unused_classes.append(
             {
@@ -207,7 +182,6 @@ class EnhancedUsageAnalyzer(ast.NodeVisitor):
         self._visit_with_scope(node)
 
     def _process_assignment(self, node: ast.Assign) -> None:
-        """Process variable assignments."""
         for target in node.targets:
             if isinstance(target, ast.Name):
                 self.collector.defined_names.add(target.id)
@@ -217,20 +191,17 @@ class EnhancedUsageAnalyzer(ast.NodeVisitor):
         self.generic_visit(node)
 
     def _process_annotated_assignment(self, node: ast.AnnAssign) -> None:
-        """Process annotated assignments."""
         if isinstance(node.target, ast.Name):
             self.collector.defined_names.add(node.target.id)
         self.generic_visit(node)
 
     def _process_name_usage(self, node: ast.Name) -> None:
-        """Process name usage (variable references)."""
         if isinstance(node.ctx, ast.Load):
             self.collector.used_names.add(node.id)
             if self.scope_stack:
                 self.scope_stack[-1].add(node.id)
 
     def _process_function_call(self, node: ast.Call) -> None:
-        """Process function/method calls."""
         if isinstance(node.func, ast.Name):
             self.function_calls.add(node.func.id)
             self.collector.used_names.add(node.func.id)
@@ -241,19 +212,16 @@ class EnhancedUsageAnalyzer(ast.NodeVisitor):
         self.generic_visit(node)
 
     def _process_attribute_access(self, node: ast.Attribute) -> None:
-        """Process attribute access."""
         if isinstance(node.value, ast.Name):
             self.collector.used_names.add(node.value.id)
         self.generic_visit(node)
 
     def _should_track_function(self, name: str) -> bool:
-        """Determine if function should be tracked for unused analysis."""
         return not name.startswith("_") and name != "__init__"
 
     def _create_function_info(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> dict[str, t.Any]:
-        """Create function information dictionary."""
         return {
             "name": node.name,
             "line": node.lineno,
@@ -264,7 +232,6 @@ class EnhancedUsageAnalyzer(ast.NodeVisitor):
     def _create_variable_info(
         self, target: ast.Name, node: ast.Assign
     ) -> dict[str, t.Any]:
-        """Create variable information dictionary."""
         return {
             "name": target.id,
             "line": node.lineno,
@@ -272,11 +239,9 @@ class EnhancedUsageAnalyzer(ast.NodeVisitor):
         }
 
     def _is_in_function_or_class_scope(self) -> bool:
-        """Check if currently in function or class scope."""
         return len(self.scope_stack) > 1
 
     def _visit_with_scope(self, node: ast.AST) -> None:
-        """Visit node with proper scope tracking."""
         self.scope_stack.append(set())
         self.generic_visit(node)
         self.scope_stack.pop()

crackerjack/agents/security_agent.py

@@ -24,11 +24,9 @@ class SecurityAgent(SubAgent):
 
         message_lower = issue.message.lower()
 
-        # High confidence (0.95) for regex validation issues
         if issue.type == IssueType.REGEX_VALIDATION:
             return 0.95
 
-        # High confidence (0.95) for regex validation keywords
         if any(
             keyword in message_lower
             for keyword in (
@@ -44,7 +42,6 @@ class SecurityAgent(SubAgent):
         ):
             return 0.95
 
-        # High confidence (0.9) for critical security issues
         if any(
             keyword in message_lower
             for keyword in (
@@ -68,7 +65,6 @@ class SecurityAgent(SubAgent):
         ):
             return 0.9
 
-        # Enhanced detection using new security patterns
         enhanced_patterns = [
             "detect_security_keywords",
             "detect_crypto_weak_algorithms",
@@ -81,14 +77,12 @@ class SecurityAgent(SubAgent):
             if SAFE_PATTERNS[pattern_name].test(issue.message):
                 return 0.9
 
-        # Medium confidence for security-related files
         if issue.file_path and any(
             keyword in issue.file_path.lower()
             for keyword in ("security", "auth", "crypto", "password", "token", "jwt")
         ):
             return 0.7
 
-        # Base confidence for security type
         if issue.type == IssueType.SECURITY:
             return 0.6
 
@@ -156,7 +150,7 @@ class SecurityAgent(SubAgent):
             "insecure_random": self._fix_insecure_random,
         }
 
-        if fix_method := vulnerability_fix_map.get(vulnerability_type):
+        if (fix_method := vulnerability_fix_map.get(vulnerability_type)) is not None:
             fixes = await fix_method(issue)
             fixes_applied.extend(fixes["fixes"])
             files_modified.extend(fixes["files"])
@@ -184,7 +178,7 @@ class SecurityAgent(SubAgent):
     def _get_security_recommendations(self) -> list[str]:
         return [
             "Use centralized SAFE_PATTERNS for regex operations to prevent ReDoS attacks",
-            "Avoid raw regex patterns with vulnerable replacement syntax like \\g < 1 >",
+            "Avoid raw regex patterns with vulnerable replacement syntax like \\g<1>",
             "Use tempfile module for temporary file creation instead of hardcoded paths",
             "Avoid shell=True in subprocess calls to prevent command injection",
             "Store secrets in environment variables using os.getenv(), never hardcode them",
@@ -215,33 +209,27 @@ class SecurityAgent(SubAgent):
     def _identify_vulnerability_type(self, issue: Issue) -> str:
         message = issue.message
 
-        # Regex validation issues
         if self._is_regex_validation_issue(issue):
             return "regex_validation"
 
-        # Enhanced pattern-based detection
         pattern_checks = self._check_enhanced_patterns(message)
         if pattern_checks:
             return pattern_checks
 
-        # Bandit code-based detection
         bandit_checks = self._check_bandit_patterns(message)
         if bandit_checks:
             return bandit_checks
 
-        # Legacy pattern-based detection
         legacy_checks = self._check_legacy_patterns(message)
         if legacy_checks:
             return legacy_checks
 
-        # JWT and other specific patterns
         if self._is_jwt_secret_issue(message):
             return "jwt_secrets"
 
         return "unknown"
 
     def _is_regex_validation_issue(self, issue: Issue) -> bool:
-        """Check if issue is related to regex validation."""
         if issue.type == IssueType.REGEX_VALIDATION:
             return True
 
@@ -258,7 +246,6 @@ class SecurityAgent(SubAgent):
         )
 
     def _check_enhanced_patterns(self, message: str) -> str | None:
-        """Check enhanced security patterns."""
         pattern_map = {
             "detect_crypto_weak_algorithms": "weak_crypto",
             "detect_hardcoded_credentials_advanced": "hardcoded_secrets",
@@ -274,7 +261,6 @@ class SecurityAgent(SubAgent):
         return None
 
     def _check_bandit_patterns(self, message: str) -> str | None:
-        """Check Bandit-specific patterns."""
         if "B108" in message:
             return "hardcoded_temp_paths"
         if "B602" in message or "shell=True" in message:
@@ -289,7 +275,6 @@ class SecurityAgent(SubAgent):
         return None
 
     def _check_legacy_patterns(self, message: str) -> str | None:
-        """Check legacy security patterns."""
         pattern_map = {
             "detect_hardcoded_temp_paths_basic": "hardcoded_temp_paths",
             "detect_hardcoded_secrets": "hardcoded_secrets",
@@ -303,19 +288,16 @@ class SecurityAgent(SubAgent):
         return None
 
     def _is_jwt_secret_issue(self, message: str) -> bool:
-        """Check if message indicates JWT secret issue."""
         message_lower = message.lower()
         return "jwt" in message_lower and (
             "secret" in message_lower or "hardcoded" in message_lower
         )
 
     async def _fix_regex_validation_issues(self, issue: Issue) -> dict[str, list[str]]:
-        """Fix unsafe regex patterns by converting them to use centralized SAFE_PATTERNS."""
         fixes: list[str] = []
         files: list[str] = []
 
         if not issue.file_path:
-            # If no specific file path, scan all Python files in the project
             await self._fix_regex_patterns_project_wide(fixes, files)
             return {"fixes": fixes, "files": files}
 
@@ -341,7 +323,6 @@ class SecurityAgent(SubAgent):
     async def _fix_regex_patterns_project_wide(
         self, fixes: list[str], files: list[str]
     ) -> None:
-        """Fix regex patterns across the entire project."""
         try:
             python_files = self._get_python_files_for_security_scan()
             await self._process_python_files_for_regex_fixes(python_files, fixes, files)
@@ -349,28 +330,24 @@ class SecurityAgent(SubAgent):
             self.log(f"Error during project-wide regex fixes: {e}", "ERROR")
 
     def _get_python_files_for_security_scan(self) -> list[Path]:
-        """Get list of Python files that should be scanned for security issues."""
         python_files = list(self.context.project_path.rglob("*.py"))
         return [
             f for f in python_files if not self._should_skip_file_for_security_scan(f)
         ]
 
     def _should_skip_file_for_security_scan(self, file_path: Path) -> bool:
-        """Check if a file should be skipped during security scanning."""
         skip_patterns = [".venv", "__pycache__", ".git"]
         return any(part in str(file_path) for part in skip_patterns)
 
     async def _process_python_files_for_regex_fixes(
         self, python_files: list[Path], fixes: list[str], files: list[str]
     ) -> None:
-        """Process each Python file for regex fixes."""
         for file_path in python_files:
             await self._process_single_file_for_regex_fixes(file_path, fixes, files)
 
     async def _process_single_file_for_regex_fixes(
         self, file_path: Path, fixes: list[str], files: list[str]
     ) -> None:
-        """Process a single file for regex pattern fixes."""
         content = self.context.get_file_content(file_path)
         if not content:
             return
@@ -382,27 +359,22 @@ class SecurityAgent(SubAgent):
             await self._save_regex_fixes_to_file(file_path, content, fixes, files)
 
     def _should_save_regex_fixes(self, content: str, original_content: str) -> bool:
-        """Check if regex fixes should be saved."""
         return content != original_content
 
     async def _save_regex_fixes_to_file(
         self, file_path: Path, content: str, fixes: list[str], files: list[str]
     ) -> None:
-        """Save regex fixes to file and update tracking lists."""
         if self.context.write_file_content(file_path, content):
             fixes.append(f"Fixed unsafe regex patterns in {file_path}")
             files.append(str(file_path))
             self.log(f"Fixed regex patterns in {file_path}")
 
     async def _apply_regex_pattern_fixes(self, content: str) -> str:
-        """Apply all regex pattern fixes using SAFE_PATTERNS."""
-        # Import regex fix utilities
         from crackerjack.services.regex_utils import (
             replace_unsafe_regex_with_safe_patterns,
         )
 
         try:
-            # Apply centralized regex fixes
             fixed_content = replace_unsafe_regex_with_safe_patterns(content)
             return fixed_content
         except Exception as e:
@@ -464,12 +436,9 @@ class SecurityAgent(SubAgent):
         return lines, True
 
     def _replace_hardcoded_temp_paths(self, lines: list[str]) -> tuple[list[str], bool]:
-        # Apply temp path replacements using SAFE_PATTERNS
         new_content = "\n".join(lines)
 
-        # Check if any temp paths need replacement
         if SAFE_PATTERNS["detect_hardcoded_temp_paths_basic"].test(new_content):
-            # Apply multiple replacement patterns
             new_content = SAFE_PATTERNS["replace_hardcoded_temp_paths"].apply(
                 new_content
             )
@@ -571,9 +540,11 @@ class SecurityAgent(SubAgent):
         return SAFE_PATTERNS["detect_hardcoded_secrets"].test(line)
 
     def _replace_hardcoded_secret_with_env_var(self, line: str) -> str:
-        # Extract variable name using safe patterns
-        var_name = SAFE_PATTERNS["extract_variable_name_from_assignment"].apply(line)
-        if var_name != line:  # If pattern matched and extracted something
+        var_name_result = SAFE_PATTERNS["extract_variable_name_from_assignment"].apply(
+            line
+        )
+        if var_name_result != line:  # Pattern matched and extracted variable name
+            var_name = var_name_result
             env_var_name = var_name.upper()
             return f"{var_name} = os.getenv('{env_var_name}', '')"
         return line
@@ -642,7 +613,6 @@ class SecurityAgent(SubAgent):
         return {"fixes": fixes, "files": files}
 
     async def _fix_jwt_secrets(self, issue: Issue) -> dict[str, list[str]]:
-        """Fix hardcoded JWT secrets by replacing with environment variables."""
         fixes: list[str] = []
         files: list[str] = []
 
@@ -656,10 +626,8 @@ class SecurityAgent(SubAgent):
 
         original_content = content
 
-        # Apply JWT secret fix pattern
         content = SAFE_PATTERNS["fix_hardcoded_jwt_secret"].apply(content)
 
-        # Ensure os import is present
         if "os.getenv" in content and "import os" not in content:
             lines = content.split("\n")
             import_index = 0
@@ -678,7 +646,6 @@ class SecurityAgent(SubAgent):
         return {"fixes": fixes, "files": files}
 
     async def _fix_pickle_usage(self, issue: Issue) -> dict[str, list[str]]:
-        """Fix unsafe pickle usage by documenting the security risk."""
         fixes: list[str] = []
         files: list[str] = []
 
@@ -690,19 +657,16 @@ class SecurityAgent(SubAgent):
         if not content:
             return {"fixes": fixes, "files": files}
 
-        # For pickle usage, we document the risk rather than auto-fixing
-        # as pickle is sometimes necessary and the fix depends on context
         fixes.append(
             f"Documented unsafe pickle usage in {issue.file_path} - manual review required"
         )
 
-        # Add a security comment if pickle.load/loads is found
         if "pickle.load" in content:
             lines = content.split("\n")
             for i, line in enumerate(lines):
-                if "pickle.load" in line and "# SECURITY:" not in line:
+                if "pickle.load" in line and "# SECURITY: " not in line:
                     lines[i] = (
-                        line + "  # SECURITY: pickle.load is unsafe with untrusted data"
+                        line + " # SECURITY: pickle.load is unsafe with untrusted data"
                     )
                     if self.context.write_file_content(file_path, "\n".join(lines)):
                         fixes.append(
@@ -717,7 +681,6 @@ class SecurityAgent(SubAgent):
         return {"fixes": fixes, "files": files}
 
     async def _fix_insecure_random(self, issue: Issue) -> dict[str, list[str]]:
-        """Fix insecure random usage by replacing with secrets module."""
         fixes: list[str] = []
         files: list[str] = []
 
@@ -731,10 +694,8 @@ class SecurityAgent(SubAgent):
 
         original_content = content
 
-        # Apply insecure random fix
         content = SAFE_PATTERNS["fix_insecure_random_choice"].apply(content)
 
-        # Ensure secrets import
         if "secrets.choice" in content and "import secrets" not in content:
             lines = content.split("\n")
             import_index = 0