crackerjack 0.18.2__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/agents/helpers/refactoring/dead_code_detector.py

@@ -0,0 +1,437 @@
+"""Dead code detection and removal logic."""
+
+import ast
+import typing as t
+
+from ...base import AgentContext
+
+
+class DeadCodeDetector:
+    """Detects dead code including unused imports and unreachable code."""
+
+    def __init__(self, context: AgentContext) -> None:
+        """Initialize detector with agent context.
+
+        Args:
+            context: AgentContext for logging
+        """
+        self.context = context
+
+    def analyze_dead_code(self, tree: ast.AST, content: str) -> dict[str, t.Any]:
+        """Analyze code for dead code patterns.
+
+        Args:
+            tree: AST tree
+            content: File content
+
+        Returns:
+            Analysis results
+        """
+        analysis: dict[str, list[t.Any]] = {
+            "unused_imports": [],
+            "unused_variables": [],
+            "unused_functions": [],
+            "unused_classes": [],
+            "unreachable_code": [],
+            "removable_items": [],
+        }
+
+        analyzer_result = self._collect_usage_data(tree)
+        self._process_unused_imports(analysis, analyzer_result)
+        self._process_unused_functions(analysis, analyzer_result)
+        self._process_unused_classes(analysis, analyzer_result)
+        self._detect_unreachable_code(analysis, tree, content)
+        self._detect_redundant_code(analysis, tree, content)
+
+        return analysis
+
+    def _collect_usage_data(self, tree: ast.AST) -> dict[str, t.Any]:
+        """Collect usage data from AST.
+
+        Args:
+            tree: AST tree
+
+        Returns:
+            Usage data
+        """
+        collector = UsageDataCollector()
+        analyzer = EnhancedUsageAnalyzer(collector)
+        analyzer.visit(tree)
+        return collector.get_results(analyzer)
+
+    @staticmethod
+    def _process_unused_imports(
+        analysis: dict[str, t.Any],
+        analyzer_result: dict[str, t.Any],
+    ) -> None:
+        """Process unused imports.
+
+        Args:
+            analysis: Analysis dict
+            analyzer_result: Analyzer result
+        """
+        import_lines: list[tuple[int, str, str]] = analyzer_result["import_lines"]
+        for line_no, name, import_type in import_lines:
+            if name not in analyzer_result["used_names"]:
+                analysis["unused_imports"].append(
+                    {
+                        "name": name,
+                        "line": line_no,
+                        "type": import_type,
+                    },
+                )
+                analysis["removable_items"].append(f"unused import: {name}")
+
+    @staticmethod
+    def _process_unused_functions(
+        analysis: dict[str, t.Any],
+        analyzer_result: dict[str, t.Any],
+    ) -> None:
+        """Process unused functions.
+
+        Args:
+            analysis: Analysis dict
+            analyzer_result: Analyzer result
+        """
+        all_unused_functions: list[dict[str, t.Any]] = analyzer_result[
+            "unused_functions"
+        ]
+        unused_functions = [
+            func
+            for func in all_unused_functions
+            if func["name"] not in analyzer_result["used_names"]
+        ]
+        analysis["unused_functions"] = unused_functions
+        for func in unused_functions:
+            analysis["removable_items"].append(f"unused function: {func['name']}")
+
+    @staticmethod
+    def _process_unused_classes(
+        analysis: dict[str, t.Any], analyzer_result: dict[str, t.Any]
+    ) -> None:
+        """Process unused classes.
+
+        Args:
+            analysis: Analysis dict
+            analyzer_result: Analyzer result
+        """
+        if "unused_classes" not in analyzer_result:
+            return
+
+        unused_classes = [
+            cls
+            for cls in analyzer_result["unused_classes"]
+            if cls["name"] not in analyzer_result["used_names"]
+        ]
+
+        analysis["unused_classes"] = unused_classes
+        for cls in unused_classes:
+            analysis["removable_items"].append(f"unused class: {cls['name']}")
+
+    @staticmethod
+    def _detect_unreachable_code(
+        analysis: dict[str, t.Any], tree: ast.AST, content: str
+    ) -> None:
+        """Detect unreachable code.
+
+        Args:
+            analysis: Analysis dict
+            tree: AST tree
+            content: File content
+        """
+
+        class UnreachableCodeDetector(ast.NodeVisitor):
+            def __init__(self) -> None:
+                self.unreachable_blocks: list[dict[str, t.Any]] = []
+
+            def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+                self._check_unreachable_in_function(node)
+                self.generic_visit(node)
+
+            def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+                self._check_unreachable_in_function(node)
+                self.generic_visit(node)
+
+            def _check_unreachable_in_function(
+                self, node: ast.FunctionDef | ast.AsyncFunctionDef
+            ) -> None:
+                for i, stmt in enumerate(node.body):
+                    if isinstance(stmt, ast.Return | ast.Raise):
+                        if i + 1 < len(node.body):
+                            next_stmt = node.body[i + 1]
+                            self.unreachable_blocks.append(
+                                {
+                                    "type": "unreachable_after_return",
+                                    "line": next_stmt.lineno,
+                                    "function": node.name,
+                                }
+                            )
+
+        detector = UnreachableCodeDetector()
+        detector.visit(tree)
+
+        analysis["unreachable_code"] = detector.unreachable_blocks
+        for block in detector.unreachable_blocks:
+            analysis["removable_items"].append(
+                f"unreachable code after line {block['line']} in {block['function']}"
+            )
+
+    @staticmethod
+    def _detect_redundant_code(
+        analysis: dict[str, t.Any], tree: ast.AST, content: str
+    ) -> None:
+        """Detect redundant code patterns.
+
+        Args:
+            analysis: Analysis dict
+            tree: AST tree
+            content: File content
+        """
+        lines = content.split("\n")
+
+        line_hashes = {}
+        for i, line in enumerate(lines):
+            if line.strip() and not line.strip().startswith("#"):
+                line_hash = hash(line.strip())
+                if line_hash in line_hashes:
+                    analysis["removable_items"].append(
+                        f"potential duplicate code at line {i + 1}"
+                    )
+                line_hashes[line_hash] = i
+
+        class RedundantPatternDetector(ast.NodeVisitor):
+            def __init__(self) -> None:
+                self.redundant_items: list[dict[str, t.Any]] = []
+
+            def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+                if len(node.body) == 1 and isinstance(node.body[0], ast.Pass):
+                    self.redundant_items.append(
+                        {"type": "empty_except", "line": node.lineno}
+                    )
+                self.generic_visit(node)
+
+            def visit_If(self, node: ast.If) -> None:
+                if isinstance(node.test, ast.Constant):
+                    if node.test.value is True:
+                        self.redundant_items.append(
+                            {"type": "if_true", "line": node.lineno}
+                        )
+                    elif node.test.value is False:
+                        self.redundant_items.append(
+                            {"type": "if_false", "line": node.lineno}
+                        )
+                self.generic_visit(node)
+
+        detector = RedundantPatternDetector()
+        detector.visit(tree)
+
+        for item in detector.redundant_items:
+            analysis["removable_items"].append(
+                f"redundant {item['type']} at line {item['line']}"
+            )
+
+    def find_lines_to_remove(
+        self, lines: list[str], analysis: dict[str, t.Any]
+    ) -> set[int]:
+        """Find lines to remove.
+
+        Args:
+            lines: File lines
+            analysis: Analysis results
+
+        Returns:
+            Set of line indices to remove
+        """
+        lines_to_remove: set[int] = set()
+
+        for unused_import in analysis["unused_imports"]:
+            line_idx = unused_import["line"] - 1
+            if 0 <= line_idx < len(lines):
+                line = lines[line_idx]
+                if self._should_remove_import_line(line, unused_import):
+                    lines_to_remove.add(line_idx)
+
+        return lines_to_remove
+
+    @staticmethod
+    def _should_remove_import_line(line: str, unused_import: dict[str, str]) -> bool:
+        """Check if import line should be removed.
+
+        Args:
+            line: Code line
+            unused_import: Unused import info
+
+        Returns:
+            True if should remove
+        """
+        if unused_import["type"] == "import":
+            return f"import {unused_import['name']}" in line
+        elif unused_import["type"] == "from_import":
+            return (
+                "from " in line
+                and unused_import["name"] in line
+                and line.strip().endswith(unused_import["name"])
+            )
+        return False
+
+    @staticmethod
+    def _find_unreachable_lines(
+        lines: list[str], analysis: dict[str, t.Any]
+    ) -> set[int]:
+        """Find unreachable code lines.
+
+        Args:
+            lines: File lines
+            analysis: Analysis results
+
+        Returns:
+            Set of line indices
+        """
+        lines_to_remove: set[int] = set()
+
+        for item in analysis.get("unreachable_code", []):
+            if "line" in item:
+                line_idx = item["line"] - 1
+                if 0 <= line_idx < len(lines):
+                    lines_to_remove.add(line_idx)
+
+        return lines_to_remove
+
+    @staticmethod
+    def _find_redundant_lines(lines: list[str], analysis: dict[str, t.Any]) -> set[int]:
+        """Find redundant code lines.
+
+        Args:
+            lines: File lines
+            analysis: Analysis results
+
+        Returns:
+            Set of line indices
+        """
+        lines_to_remove: set[int] = set()
+
+        for i in range(len(lines)):
+            if DeadCodeDetector._is_empty_except_block(lines, i):
+                empty_pass_idx = DeadCodeDetector._find_empty_pass_line(lines, i)
+                if empty_pass_idx is not None:
+                    lines_to_remove.add(empty_pass_idx)
+
+        return lines_to_remove
+
+    @staticmethod
+    def _is_empty_except_block(lines: list[str], line_idx: int) -> bool:
+        """Check if except block is empty.
+
+        Args:
+            lines: File lines
+            line_idx: Line index
+
+        Returns:
+            True if empty except block
+        """
+        stripped = lines[line_idx].strip()
+        return stripped == "except: " or stripped.startswith("except ")
+
+    @staticmethod
+    def _find_empty_pass_line(lines: list[str], except_idx: int) -> int | None:
+        """Find empty pass line in except block.
+
+        Args:
+            lines: File lines
+            except_idx: Except line index
+
+        Returns:
+            Pass line index or None
+        """
+        for j in range(except_idx + 1, min(except_idx + 5, len(lines))):
+            next_line = lines[j].strip()
+            if not next_line:
+                continue
+            if next_line == "pass":
+                return j
+            break
+        return None
+
+
+class UsageDataCollector:
+    """Collects usage data from AST traversal."""
+
+    def __init__(self) -> None:
+        """Initialize collector."""
+        self.imports: dict[str, str] = {}
+        self.import_lines: list[tuple[int, str, str]] = []
+        self.functions: list[dict[str, t.Any]] = []
+        self.classes: list[dict[str, t.Any]] = []
+        self.usages: set[str] = set()
+
+    def get_results(self, analyzer: "EnhancedUsageAnalyzer") -> dict[str, t.Any]:
+        """Get collection results.
+
+        Args:
+            analyzer: Enhanced usage analyzer
+
+        Returns:
+            Results dict
+        """
+        return {
+            "import_lines": self.import_lines,
+            "used_names": analyzer.used_names,
+            "unused_functions": self.functions,
+            "unused_classes": self.classes,
+        }
+
+
+class EnhancedUsageAnalyzer(ast.NodeVisitor):
+    """Enhanced analyzer for tracking usage."""
+
+    def __init__(self, collector: UsageDataCollector) -> None:
+        """Initialize analyzer.
+
+        Args:
+            collector: Usage data collector
+        """
+        self.collector = collector
+        self.used_names: set[str] = set()
+        self.line_counter = 0
+
+    def visit_Import(self, node: ast.Import) -> None:
+        """Visit import statement."""
+        for alias in node.names:
+            name = alias.asname or alias.name
+            self.collector.import_lines.append((node.lineno, name, "import"))
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        """Visit from import statement."""
+        for alias in node.names:
+            name = alias.asname or alias.name
+            self.collector.import_lines.append((node.lineno, name, "from_import"))
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """Visit function definition."""
+        self.collector.functions.append({"name": node.name, "line": node.lineno})
+        self.used_names.add(node.name)
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        """Visit class definition."""
+        self.collector.classes.append({"name": node.name, "line": node.lineno})
+        self.used_names.add(node.name)
+        self.generic_visit(node)
+
+    def visit_Name(self, node: ast.Name) -> None:
+        """Visit name reference."""
+        self.used_names.add(node.id)
+        self.generic_visit(node)
+
+    def visit_Attribute(self, node: ast.Attribute) -> None:
+        """Visit attribute access."""
+        self.used_names.add(node.attr)
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        """Visit function call."""
+        if isinstance(node.func, ast.Name):
+            self.used_names.add(node.func.id)
+        self.generic_visit(node)

crackerjack/agents/helpers/test_creation/__init__.py

@@ -0,0 +1,19 @@
+"""Test creation helper modules.
+
+This package provides modular helpers for test creation:
+- TestASTAnalyzer: AST parsing and code structure extraction
+- TestTemplateGenerator: Test template generation
+- TestCoverageAnalyzer: Coverage analysis and gap detection
+
+All helpers use AgentContext pattern (legacy, intentional).
+"""
+
+from .test_ast_analyzer import TestASTAnalyzer
+from .test_coverage_analyzer import TestCoverageAnalyzer
+from .test_template_generator import TestTemplateGenerator
+
+__all__ = [
+    "TestASTAnalyzer",
+    "TestCoverageAnalyzer",
+    "TestTemplateGenerator",
+]

crackerjack/agents/helpers/test_creation/test_ast_analyzer.py

@@ -0,0 +1,216 @@
+"""AST parsing helper for test creation.
+
+This module provides AST analysis capabilities for extracting code structure
+from Python source files. Uses AgentContext pattern (legacy, intentional).
+"""
+
+import ast
+from pathlib import Path
+from typing import Any
+
+from crackerjack.agents.base import AgentContext
+
+
+class TestASTAnalyzer:
+    """AST parsing helper for test creation.
+
+    Uses AgentContext pattern (legacy, intentional).
+    """
+
+    def __init__(self, context: AgentContext) -> None:
+        self.context = context
+
+    async def extract_functions_from_file(
+        self,
+        file_path: Path,
+    ) -> list[dict[str, Any]]:
+        """Extract all functions from a Python file."""
+        functions: list[dict[str, Any]] = []
+
+        try:
+            content = self.context.get_file_content(file_path)
+            if not content:
+                return functions
+
+            tree = ast.parse(content)
+            functions = self._parse_function_nodes(tree)
+
+        except Exception as e:
+            self._log(f"Error parsing file {file_path}: {e}", "WARN")
+
+        return functions
+
+    def _parse_function_nodes(self, tree: ast.AST) -> list[dict[str, Any]]:
+        """Parse function nodes from AST."""
+        functions: list[dict[str, Any]] = []
+
+        for node in ast.walk(tree):
+            if isinstance(
+                node, ast.FunctionDef | ast.AsyncFunctionDef
+            ) and self._is_valid_function_node(node):
+                function_info = self._create_function_info(node)
+
+                function_info["is_async"] = isinstance(node, ast.AsyncFunctionDef)
+                functions.append(function_info)
+
+        return functions
+
+    def _is_valid_function_node(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> bool:
+        """Check if function node should be included."""
+        return not node.name.startswith(("_", "test_"))
+
+    def _create_function_info(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> dict[str, Any]:
+        """Create function info dict from AST node."""
+        return {
+            "name": node.name,
+            "line": node.lineno,
+            "signature": self._get_function_signature(node),
+            "args": [arg.arg for arg in node.args.args],
+            "returns": self._get_return_annotation(node),
+            "is_async": isinstance(node, ast.AsyncFunctionDef),
+            "docstring": ast.get_docstring(node) or "",
+        }
+
+    async def extract_classes_from_file(self, file_path: Path) -> list[dict[str, Any]]:
+        """Extract all classes from a Python file."""
+        classes: list[dict[str, Any]] = []
+
+        try:
+            content = self.context.get_file_content(file_path)
+            if not content:
+                return classes
+
+            tree = ast.parse(content)
+            classes = self._process_ast_nodes_for_classes(tree)
+
+        except Exception as e:
+            self._log(f"Error parsing classes from {file_path}: {e}", "WARN")
+
+        return classes
+
+    def _process_ast_nodes_for_classes(self, tree: ast.AST) -> list[dict[str, Any]]:
+        """Process AST nodes to extract class information."""
+        classes: list[dict[str, Any]] = []
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef) and self._should_include_class(node):
+                class_info = self._create_class_info(node)
+                classes.append(class_info)
+
+        return classes
+
+    def _should_include_class(self, node: ast.ClassDef) -> bool:
+        """Check if class should be included in analysis."""
+        return not node.name.startswith("_")
+
+    def _create_class_info(self, node: ast.ClassDef) -> dict[str, Any]:
+        """Create class info dict from AST node."""
+        methods = self._extract_public_methods_from_class(node)
+        return {"name": node.name, "line": node.lineno, "methods": methods}
+
+    def _extract_public_methods_from_class(self, node: ast.ClassDef) -> list[str]:
+        """Extract public method names from class node."""
+        return [
+            item.name
+            for item in node.body
+            if isinstance(item, ast.FunctionDef) and not item.name.startswith("_")
+        ]
+
+    def _get_function_signature(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> str:
+        """Get function signature string."""
+        args = [arg.arg for arg in node.args.args]
+        prefix = "async " if isinstance(node, ast.AsyncFunctionDef) else ""
+        return f"{prefix}{node.name}({', '.join(args)})"
+
+    def _get_return_annotation(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> str:
+        """Get return type annotation string."""
+        if node.returns:
+            return ast.unparse(node.returns) if (hasattr(ast, "unparse")) else "Any"
+        return "Any"
+
+    async def function_has_test(
+        self,
+        func_info: dict[str, Any],
+        file_path: Path,
+    ) -> bool:
+        """Check if a function has corresponding test."""
+        test_file_path = await self.generate_test_file_path(file_path)
+
+        if not test_file_path.exists():
+            return False
+
+        test_content = self.context.get_file_content(test_file_path)
+        if not test_content:
+            return False
+
+        test_patterns = [
+            f"test_{func_info['name']}",
+            f"test_{func_info['name']}_",
+            f"def test_{func_info['name']}",
+        ]
+
+        return any(pattern in test_content for pattern in test_patterns)
+
+    async def generate_test_file_path(self, source_file: Path) -> Path:
+        """Generate path for test file corresponding to source file."""
+        tests_dir = self.context.project_path / "tests"
+        tests_dir.mkdir(exist_ok=True)
+
+        relative_path = source_file.relative_to(
+            self.context.project_path / "crackerjack",
+        )
+        test_name = f"test_{relative_path.stem}.py"
+
+        return tests_dir / test_name
+
+    def get_module_import_path(self, file_path: Path) -> str:
+        """Get module import path from file path."""
+        try:
+            relative_path = file_path.relative_to(self.context.project_path)
+            parts = (*relative_path.parts[:-1], relative_path.stem)
+            return ".".join(parts)
+        except ValueError:
+            return file_path.stem
+
+    def should_skip_module_for_coverage(self, py_file: Path) -> bool:
+        """Check if module should be skipped for coverage analysis."""
+        return py_file.name.startswith("test_") or py_file.name == "__init__.py"
+
+    def should_skip_file_for_testing(self, py_file: Path) -> bool:
+        """Check if file should be skipped for testing."""
+        return py_file.name.startswith("test_")
+
+    def has_corresponding_test(self, file_path: str) -> bool:
+        """Check if source file has corresponding test file."""
+        path = Path(file_path)
+
+        test_patterns = [
+            f"test_{path.stem}.py",
+            f"{path.stem}_test.py",
+            f"test_{path.stem}_*.py",
+        ]
+
+        tests_dir = self.context.project_path / "tests"
+        if tests_dir.exists():
+            for pattern in test_patterns:
+                if list(tests_dir.glob(pattern)):
+                    return True
+
+        return False
+
+    def get_relative_module_path(self, py_file: Path) -> str:
+        """Get relative module path from project root."""
+        return str(py_file.relative_to(self.context.project_path))
+
+    def _log(self, message: str, level: str = "INFO") -> None:
+        """Log message through context."""
+        # This is a helper - logging would typically go through the agent
+        pass