codegraph-cli 2.0.0__py3-none-any.whl

codegraph_cli/testgen_agent.py

@@ -0,0 +1,316 @@
+"""TestGenAgent for graph-powered test generation."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+from typing import List, Optional
+
+from .llm import LocalLLM
+from .models_v2 import TestCase
+from .storage import GraphStore
+
+
+class TestGenAgent:
+    """Generates tests based on call graph analysis and usage patterns."""
+    
+    def __init__(self, store: GraphStore, llm: Optional[LocalLLM] = None):
+        """Initialize TestGenAgent.
+        
+        Args:
+            store: Graph store for analyzing code
+            llm: Optional LLM for generating test code
+        """
+        self.store = store
+        self.llm = llm
+    
+    def generate_unit_tests(self, symbol: str) -> List[TestCase]:
+        """Generate unit tests for a function.
+        
+        Args:
+            symbol: Function name to generate tests for
+            
+        Returns:
+            List of generated test cases
+        """
+        # Get function info from graph
+        node = self.store.get_node(symbol)
+        if not node:
+            raise ValueError(f"Symbol '{symbol}' not found")
+        
+        # Analyze function signature and dependencies
+        test_cases = []
+        
+        # Parse function to understand parameters
+        try:
+            tree = ast.parse(node["code"])
+            func_def = None
+            for node_ast in ast.walk(tree):
+                if isinstance(node_ast, ast.FunctionDef):
+                    func_def = node_ast
+                    break
+            
+            if func_def:
+                # Generate tests based on function analysis
+                test_cases.extend(self._generate_basic_tests(symbol, func_def, node))
+                test_cases.extend(self._generate_edge_case_tests(symbol, func_def, node))
+                test_cases.extend(self._generate_error_tests(symbol, func_def, node))
+        
+        except Exception:
+            # Fallback: generate basic test template
+            test_cases.append(self._generate_basic_test_template(symbol, node))
+        
+        return test_cases
+    
+    def generate_integration_tests(self, flow_description: str) -> List[TestCase]:
+        """Generate integration tests for a user flow.
+        
+        Args:
+            flow_description: Description of the flow to test
+            
+        Returns:
+            List of integration test cases
+        """
+        # Use LLM to generate integration test if available
+        if self.llm:
+            prompt = self._build_integration_test_prompt(flow_description)
+            test_code = self.llm.explain(prompt)
+            
+            return [TestCase(
+                name=f"test_{flow_description.lower().replace(' ', '_')}",
+                target_function=flow_description,
+                test_code=test_code,
+                description=f"Integration test for {flow_description}",
+                test_type="integration"
+            )]
+        
+        # Fallback: basic template
+        return [self._generate_integration_template(flow_description)]
+    
+    def analyze_coverage_impact(self, tests: List[TestCase]) -> dict:
+        """Predict coverage improvement from tests.
+        
+        Args:
+            tests: List of test cases
+            
+        Returns:
+            Coverage analysis dictionary
+        """
+        # Simple heuristic: estimate based on number of tests
+        # In production, would use actual coverage tools
+        
+        total_functions = len(self.store.get_nodes())
+        tested_functions = len(set(t.target_function for t in tests))
+        
+        current_coverage = 0.0  # Would get from coverage tool
+        estimated_new_coverage = min(100.0, current_coverage + (tested_functions / max(total_functions, 1)) * 100)
+        
+        return {
+            "current_coverage": current_coverage,
+            "estimated_coverage": estimated_new_coverage,
+            "coverage_increase": estimated_new_coverage - current_coverage,
+            "tests_generated": len(tests),
+            "functions_covered": tested_functions
+        }
+    
+    def _generate_basic_tests(
+        self,
+        symbol: str,
+        func_def: ast.FunctionDef,
+        node: dict
+    ) -> List[TestCase]:
+        """Generate basic happy-path tests."""
+        tests = []
+        
+        # Get parameter names
+        params = [arg.arg for arg in func_def.args.args if arg.arg != 'self']
+        
+        # Generate basic test
+        test_name = f"test_{symbol}_basic"
+        test_code = self._generate_test_code(
+            test_name,
+            symbol,
+            params,
+            "Basic functionality test"
+        )
+        
+        tests.append(TestCase(
+            name=test_name,
+            target_function=symbol,
+            test_code=test_code,
+            description=f"Test basic functionality of {symbol}",
+            test_type="unit"
+        ))
+        
+        return tests
+    
+    def _generate_edge_case_tests(
+        self,
+        symbol: str,
+        func_def: ast.FunctionDef,
+        node: dict
+    ) -> List[TestCase]:
+        """Generate edge case tests."""
+        tests = []
+        
+        params = [arg.arg for arg in func_def.args.args if arg.arg != 'self']
+        
+        # Test with empty/None values
+        if params:
+            test_name = f"test_{symbol}_empty_input"
+            test_code = self._generate_test_code(
+                test_name,
+                symbol,
+                params,
+                "Empty/None input test",
+                use_empty=True
+            )
+            
+            tests.append(TestCase(
+                name=test_name,
+                target_function=symbol,
+                test_code=test_code,
+                description=f"Test {symbol} with empty/None inputs",
+                test_type="unit"
+            ))
+        
+        return tests
+    
+    def _generate_error_tests(
+        self,
+        symbol: str,
+        func_def: ast.FunctionDef,
+        node: dict
+    ) -> List[TestCase]:
+        """Generate error handling tests."""
+        tests = []
+        
+        # Check if function has error handling
+        has_try_except = False
+        for node_ast in ast.walk(func_def):
+            if isinstance(node_ast, ast.Try):
+                has_try_except = True
+                break
+        
+        if has_try_except:
+            test_name = f"test_{symbol}_error_handling"
+            params = [arg.arg for arg in func_def.args.args if arg.arg != 'self']
+            
+            test_code = self._generate_test_code(
+                test_name,
+                symbol,
+                params,
+                "Error handling test",
+                test_error=True
+            )
+            
+            tests.append(TestCase(
+                name=test_name,
+                target_function=symbol,
+                test_code=test_code,
+                description=f"Test error handling in {symbol}",
+                test_type="unit"
+            ))
+        
+        return tests
+    
+    def _generate_test_code(
+        self,
+        test_name: str,
+        function_name: str,
+        params: List[str],
+        description: str,
+        use_empty: bool = False,
+        test_error: bool = False
+    ) -> str:
+        """Generate actual test code."""
+        lines = []
+        
+        lines.append(f"def {test_name}():")
+        lines.append(f'    """{description}."""')
+        
+        # Generate test inputs
+        if use_empty:
+            args = ", ".join(["None" for _ in params])
+        else:
+            # Generate reasonable test values
+            args = ", ".join([self._generate_test_value(p) for p in params])
+        
+        if test_error:
+            lines.append("    with pytest.raises(Exception):")
+            lines.append(f"        result = {function_name}({args})")
+        else:
+            lines.append(f"    result = {function_name}({args})")
+            lines.append("    assert result is not None")
+        
+        return "\n".join(lines)
+    
+    def _generate_test_value(self, param_name: str) -> str:
+        """Generate a test value based on parameter name."""
+        param_lower = param_name.lower()
+        
+        if 'id' in param_lower:
+            return "1"
+        elif 'name' in param_lower or 'username' in param_lower:
+            return '"test_user"'
+        elif 'email' in param_lower:
+            return '"test@example.com"'
+        elif 'password' in param_lower:
+            return '"password123"'
+        elif 'count' in param_lower or 'num' in param_lower:
+            return "10"
+        elif 'data' in param_lower:
+            return '{"key": "value"}'
+        else:
+            return '"test_value"'
+    
+    def _generate_basic_test_template(self, symbol: str, node: dict) -> TestCase:
+        """Generate a basic test template."""
+        test_code = f"""def test_{symbol}():
+    \"\"\"Test {symbol} function.\"\"\"
+    # TODO: Add test implementation
+    result = {symbol}()
+    assert result is not None
+"""
+        
+        return TestCase(
+            name=f"test_{symbol}",
+            target_function=symbol,
+            test_code=test_code,
+            description=f"Basic test for {symbol}",
+            test_type="unit"
+        )
+    
+    def _generate_integration_template(self, flow: str) -> TestCase:
+        """Generate integration test template."""
+        test_name = f"test_{flow.lower().replace(' ', '_')}"
+        
+        test_code = f"""def {test_name}():
+    \"\"\"Integration test for {flow}.\"\"\"
+    # TODO: Implement integration test
+    # 1. Setup test data
+    # 2. Execute flow
+    # 3. Verify results
+    pass
+"""
+        
+        return TestCase(
+            name=test_name,
+            target_function=flow,
+            test_code=test_code,
+            description=f"Integration test for {flow}",
+            test_type="integration"
+        )
+    
+    def _build_integration_test_prompt(self, flow: str) -> str:
+        """Build prompt for LLM to generate integration test."""
+        return f"""Generate a Python integration test for the following user flow: {flow}
+
+Include:
+1. Test setup (fixtures, test data)
+2. Step-by-step flow execution
+3. Assertions to verify each step
+4. Cleanup
+
+Use pytest framework. Output only the test code.
+"""

codegraph_cli/validation_engine.py

@@ -0,0 +1,285 @@
+"""ValidationEngine for detecting and fixing code errors."""
+
+from __future__ import annotations
+
+import ast
+import re
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from .models_v2 import FileChange, ValidationResult
+
+
+class ValidationEngine:
+    """Validates code and suggests/applies fixes for common errors."""
+    
+    def __init__(self):
+        """Initialize ValidationEngine."""
+        pass
+    
+    def diagnose_project(self, project_path: Path) -> List[dict]:
+        """Find all syntax errors in a project.
+        
+        Args:
+            project_path: Path to project root
+            
+        Returns:
+            List of error dictionaries with file, line, error info
+        """
+        errors = []
+        
+        for py_file in project_path.rglob("*.py"):
+            file_errors = self.check_file(py_file)
+            errors.extend(file_errors)
+        
+        return errors
+    
+    def check_file(self, file_path: Path) -> List[dict]:
+        """Check a single file for syntax errors.
+        
+        Args:
+            file_path: Path to Python file
+            
+        Returns:
+            List of errors found
+        """
+        errors = []
+        
+        try:
+            content = file_path.read_text()
+            ast.parse(content)
+        except SyntaxError as e:
+            errors.append({
+                "file": str(file_path),
+                "line": e.lineno,
+                "column": e.offset,
+                "error": str(e.msg),
+                "type": "SyntaxError"
+            })
+        except IndentationError as e:
+            errors.append({
+                "file": str(file_path),
+                "line": e.lineno,
+                "column": e.offset,
+                "error": str(e.msg),
+                "type": "IndentationError"
+            })
+        except Exception as e:
+            errors.append({
+                "file": str(file_path),
+                "line": 0,
+                "column": 0,
+                "error": str(e),
+                "type": type(e).__name__
+            })
+        
+        return errors
+    
+    def fix_common_errors(self, file_path: Path) -> Optional[FileChange]:
+        """Attempt to fix common syntax errors automatically.
+        
+        Args:
+            file_path: Path to file with errors
+            
+        Returns:
+            FileChange if fixes were applied, None otherwise
+        """
+        original_content = file_path.read_text()
+        fixed_content = original_content
+        fixes_applied = []
+        
+        # Check for errors
+        errors = self.check_file(file_path)
+        if not errors:
+            return None
+        
+        # Try common fixes
+        for error in errors:
+            if "invalid syntax" in error["error"].lower():
+                # Try fixing missing parentheses, brackets, quotes
+                fixed_content, fix_msg = self._fix_missing_delimiters(fixed_content, error)
+                if fix_msg:
+                    fixes_applied.append(fix_msg)
+            
+            elif "indentation" in error["error"].lower():
+                # Fix indentation issues
+                fixed_content, fix_msg = self._fix_indentation(fixed_content)
+                if fix_msg:
+                    fixes_applied.append(fix_msg)
+            
+            elif "eol while scanning" in error["error"].lower():
+                # Fix unclosed strings
+                fixed_content, fix_msg = self._fix_unclosed_strings(fixed_content, error)
+                if fix_msg:
+                    fixes_applied.append(fix_msg)
+        
+        # Verify fix worked
+        try:
+            ast.parse(fixed_content)
+            # Success!
+            return FileChange(
+                file_path=str(file_path),
+                change_type="modify",
+                original_content=original_content,
+                new_content=fixed_content
+            )
+        except:
+            # Fix didn't work, return None
+            return None
+    
+    def _fix_missing_delimiters(self, content: str, error: dict) -> Tuple[str, Optional[str]]:
+        """Try to fix missing parentheses, brackets, or braces.
+        
+        Args:
+            content: File content
+            error: Error information
+            
+        Returns:
+            (fixed_content, fix_message)
+        """
+        lines = content.splitlines(keepends=True)
+        line_num = error["line"] - 1
+        
+        if line_num >= len(lines):
+            return content, None
+        
+        line = lines[line_num]
+        
+        # Count delimiters
+        open_parens = line.count('(') - line.count(')')
+        open_brackets = line.count('[') - line.count(']')
+        open_braces = line.count('{') - line.count('}')
+        
+        fixed_line = line
+        fix_msg = None
+        
+        if open_parens > 0:
+            fixed_line = fixed_line.rstrip() + ')' * open_parens + '\n'
+            fix_msg = f"Added {open_parens} closing parenthesis"
+        elif open_brackets > 0:
+            fixed_line = fixed_line.rstrip() + ']' * open_brackets + '\n'
+            fix_msg = f"Added {open_brackets} closing bracket"
+        elif open_braces > 0:
+            fixed_line = fixed_line.rstrip() + '}' * open_braces + '\n'
+            fix_msg = f"Added {open_braces} closing brace"
+        
+        if fix_msg:
+            lines[line_num] = fixed_line
+            return "".join(lines), fix_msg
+        
+        return content, None
+    
+    def _fix_indentation(self, content: str) -> Tuple[str, Optional[str]]:
+        """Fix indentation issues (tabs vs spaces).
+        
+        Args:
+            content: File content
+            
+        Returns:
+            (fixed_content, fix_message)
+        """
+        # Convert all tabs to 4 spaces
+        if '\t' in content:
+            fixed = content.replace('\t', '    ')
+            return fixed, "Converted tabs to 4 spaces"
+        
+        return content, None
+    
+    def _fix_unclosed_strings(self, content: str, error: dict) -> Tuple[str, Optional[str]]:
+        """Fix unclosed string literals.
+        
+        Args:
+            content: File content
+            error: Error information
+            
+        Returns:
+            (fixed_content, fix_message)
+        """
+        lines = content.splitlines(keepends=True)
+        line_num = error["line"] - 1
+        
+        if line_num >= len(lines):
+            return content, None
+        
+        line = lines[line_num]
+        
+        # Count quotes
+        single_quotes = line.count("'") - line.count("\\'")
+        double_quotes = line.count('"') - line.count('\\"')
+        
+        fixed_line = line
+        fix_msg = None
+        
+        if single_quotes % 2 == 1:
+            # Odd number of single quotes
+            fixed_line = fixed_line.rstrip() + "'\n"
+            fix_msg = "Added closing single quote"
+        elif double_quotes % 2 == 1:
+            # Odd number of double quotes
+            fixed_line = fixed_line.rstrip() + '"\n'
+            fix_msg = "Added closing double quote"
+        
+        if fix_msg:
+            lines[line_num] = fixed_line
+            return "".join(lines), fix_msg
+        
+        return content, None
+    
+    def validate_syntax(self, code: str) -> ValidationResult:
+        """Check if code has valid Python syntax.
+        
+        Args:
+            code: Python code to validate
+            
+        Returns:
+            ValidationResult
+        """
+        try:
+            ast.parse(code)
+            return ValidationResult(valid=True)
+        except SyntaxError as e:
+            return ValidationResult(
+                valid=False,
+                errors=[f"SyntaxError at line {e.lineno}: {e.msg}"]
+            )
+        except Exception as e:
+            return ValidationResult(
+                valid=False,
+                errors=[f"{type(e).__name__}: {str(e)}"]
+            )
+    
+    def validate_imports(self, code: str) -> ValidationResult:
+        """Check if all imports are available.
+        
+        Args:
+            code: Python code to validate
+            
+        Returns:
+            ValidationResult
+        """
+        warnings = []
+        
+        try:
+            tree = ast.parse(code)
+        except:
+            return ValidationResult(valid=False, errors=["Cannot parse code"])
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    try:
+                        __import__(alias.name)
+                    except ImportError:
+                        warnings.append(f"Import '{alias.name}' may not be available")
+            
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    try:
+                        __import__(node.module)
+                    except ImportError:
+                        warnings.append(f"Module '{node.module}' may not be available")
+        
+        return ValidationResult(
+            valid=True,
+            warnings=warnings
+        )