django-cfg 1.3.9__py3-none-any.whl → 1.3.11__py3-none-any.whl

django_cfg/modules/django_app_agent/services/validation_service/quality_validator.py

@@ -1,352 +0,0 @@
-"""
-Code Quality Validator for Django App Agent.
-
-This module validates code quality metrics, patterns,
-and maintainability aspects of generated code.
-"""
-
-from typing import List, Dict, Any, Optional
-import ast
-import re
-
-from pydantic import BaseModel, Field
-
-from ...models.responses import GeneratedFile, QualityMetrics
-from ..base import ServiceDependencies
-from .models import ValidationIssue
-
-
-class QualityValidator(BaseModel):
-    """Validates code quality and maintainability patterns."""
-    
-    quality_rules: Dict[str, Dict[str, Any]] = Field(
-        default_factory=lambda: {
-            "function_complexity": {
-                "description": "Functions should not be overly complex",
-                "severity": "warning",
-                "max_complexity": 10
-            },
-            "line_length": {
-                "description": "Lines should not exceed reasonable length",
-                "severity": "warning",
-                "max_length": 120
-            },
-            "docstring_coverage": {
-                "description": "Classes and functions should have docstrings",
-                "severity": "info"
-            },
-            "type_hints": {
-                "description": "Functions should have type hints",
-                "severity": "info"
-            },
-            "naming_conventions": {
-                "description": "Follow Python naming conventions",
-                "severity": "warning"
-            },
-            "code_duplication": {
-                "description": "Avoid code duplication",
-                "severity": "warning"
-            }
-        },
-        description="Code quality validation rules"
-    )
-
-    async def validate_quality(
-        self,
-        file: GeneratedFile,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Validate code quality for a single file."""
-        issues = []
-        
-        if file.file_type != "python":
-            return issues
-        
-        try:
-            tree = ast.parse(file.content)
-            
-            # Apply quality checks
-            issues.extend(self._check_complexity(file, tree, dependencies))
-            issues.extend(self._check_line_length(file, dependencies))
-            issues.extend(self._check_docstrings(file, tree, dependencies))
-            issues.extend(self._check_type_hints(file, tree, dependencies))
-            issues.extend(self._check_naming_conventions(file, tree, dependencies))
-            issues.extend(self._check_code_duplication(file, tree, dependencies))
-            
-        except SyntaxError:
-            # Skip quality validation if syntax is invalid
-            pass
-        except Exception as e:
-            dependencies.log_error(f"Quality validation failed for {file.path}", e)
-        
-        return issues
-    
-    async def calculate_quality_metrics(
-        self,
-        files: List[GeneratedFile],
-        dependencies: ServiceDependencies
-    ) -> QualityMetrics:
-        """Calculate comprehensive quality metrics."""
-        total_lines = 0
-        total_functions = 0
-        functions_with_docstrings = 0
-        functions_with_type_hints = 0
-        classes_with_docstrings = 0
-        total_classes = 0
-        complexity_scores = []
-        
-        for file in files:
-            if file.file_type != "python":
-                continue
-                
-            try:
-                tree = ast.parse(file.content)
-                lines = file.content.split('\n')
-                total_lines += len([line for line in lines if line.strip()])
-                
-                for node in ast.walk(tree):
-                    if isinstance(node, ast.FunctionDef):
-                        total_functions += 1
-                        
-                        # Check docstring
-                        if ast.get_docstring(node):
-                            functions_with_docstrings += 1
-                        
-                        # Check type hints
-                        if self._has_type_hints(node):
-                            functions_with_type_hints += 1
-                        
-                        # Calculate complexity
-                        complexity = self._calculate_cyclomatic_complexity(node)
-                        complexity_scores.append(complexity)
-                    
-                    elif isinstance(node, ast.ClassDef):
-                        total_classes += 1
-                        if ast.get_docstring(node):
-                            classes_with_docstrings += 1
-                            
-            except SyntaxError:
-                continue
-        
-        # Calculate metrics
-        docstring_coverage = 0.0
-        if total_functions + total_classes > 0:
-            docstring_coverage = (functions_with_docstrings + classes_with_docstrings) / (total_functions + total_classes) * 100
-        
-        type_hint_coverage = 0.0
-        if total_functions > 0:
-            type_hint_coverage = functions_with_type_hints / total_functions * 100
-        
-        avg_complexity = sum(complexity_scores) / len(complexity_scores) if complexity_scores else 0
-        
-        # Calculate overall scores
-        overall_score = (docstring_coverage * 0.2 + type_hint_coverage * 0.3 + 
-                        max(0, 100 - avg_complexity * 10) * 0.5) / 10
-        
-        return QualityMetrics(
-            overall_score=min(10.0, max(0.0, overall_score)),
-            type_safety_score=min(10.0, type_hint_coverage / 10),
-            pattern_consistency=8.5,  # Would need more sophisticated analysis
-            code_complexity=max(0.0, 10.0 - avg_complexity),
-            test_coverage=0.0,  # Would need test analysis
-            documentation_coverage=min(100.0, docstring_coverage),  # Keep as percentage
-            performance_score=8.0,  # Would need performance analysis
-            security_score=8.5,  # Would need security analysis
-            maintainability_score=min(10.0, max(0.0, overall_score))
-        )
-    
-    def _check_complexity(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check cyclomatic complexity of functions."""
-        issues = []
-        max_complexity = self.quality_rules["function_complexity"]["max_complexity"]
-        
-        for node in ast.walk(tree):
-            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                complexity = self._calculate_cyclomatic_complexity(node)
-                
-                if complexity > max_complexity:
-                    issues.append(ValidationIssue(
-                        severity="warning",
-                        category="quality",
-                        message=f"Function '{node.name}' has high complexity ({complexity})",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="high_complexity",
-                        suggestion=f"Consider breaking down {node.name} into smaller functions"
-                    ))
-        
-        return issues
-    
-    def _check_line_length(
-        self,
-        file: GeneratedFile,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check for overly long lines."""
-        issues = []
-        max_length = self.quality_rules["line_length"]["max_length"]
-        
-        lines = file.content.split('\n')
-        for i, line in enumerate(lines, 1):
-            if len(line) > max_length:
-                issues.append(ValidationIssue(
-                    severity="info",
-                    category="quality",
-                    message=f"Line {i} exceeds {max_length} characters ({len(line)})",
-                    file_path=file.path,
-                    line_number=i,
-                    rule_id="line_too_long",
-                    suggestion="Break long lines for better readability"
-                ))
-        
-        return issues
-    
-    def _check_docstrings(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check for missing docstrings."""
-        issues = []
-        
-        for node in ast.walk(tree):
-            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-                if not ast.get_docstring(node):
-                    node_type = "Class" if isinstance(node, ast.ClassDef) else "Function"
-                    issues.append(ValidationIssue(
-                        severity="info",
-                        category="quality",
-                        message=f"{node_type} '{node.name}' lacks docstring",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="missing_docstring",
-                        suggestion=f"Add a docstring to {node.name} explaining its purpose"
-                    ))
-        
-        return issues
-    
-    def _check_type_hints(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check for missing type hints."""
-        issues = []
-        
-        for node in ast.walk(tree):
-            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                if not self._has_type_hints(node):
-                    issues.append(ValidationIssue(
-                        severity="info",
-                        category="quality",
-                        message=f"Function '{node.name}' lacks type hints",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="missing_type_hints",
-                        suggestion=f"Add type hints to {node.name} parameters and return value"
-                    ))
-        
-        return issues
-    
-    def _check_naming_conventions(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check Python naming conventions."""
-        issues = []
-        
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ClassDef):
-                # Class names should be PascalCase
-                if not re.match(r'^[A-Z][a-zA-Z0-9]*$', node.name):
-                    issues.append(ValidationIssue(
-                        severity="warning",
-                        category="quality",
-                        message=f"Class '{node.name}' should use PascalCase",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="class_naming",
-                        suggestion=f"Rename {node.name} to follow PascalCase convention"
-                    ))
-            
-            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                # Function names should be snake_case
-                if not re.match(r'^[a-z_][a-z0-9_]*$', node.name) and not node.name.startswith('__'):
-                    issues.append(ValidationIssue(
-                        severity="warning",
-                        category="quality",
-                        message=f"Function '{node.name}' should use snake_case",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="function_naming",
-                        suggestion=f"Rename {node.name} to follow snake_case convention"
-                    ))
-        
-        return issues
-    
-    def _check_code_duplication(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check for code duplication patterns."""
-        issues = []
-        
-        # Simple duplication check - look for identical function bodies
-        function_bodies = {}
-        
-        for node in ast.walk(tree):
-            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                # Convert function body to string for comparison
-                body_str = ast.dump(node.body)
-                
-                if body_str in function_bodies:
-                    issues.append(ValidationIssue(
-                        severity="warning",
-                        category="quality",
-                        message=f"Function '{node.name}' has duplicate body with '{function_bodies[body_str]}'",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="code_duplication",
-                        suggestion=f"Consider extracting common logic from {node.name} and {function_bodies[body_str]}"
-                    ))
-                else:
-                    function_bodies[body_str] = node.name
-        
-        return issues
-    
-    def _calculate_cyclomatic_complexity(self, node: ast.AST) -> int:
-        """Calculate cyclomatic complexity of a function."""
-        complexity = 1  # Base complexity
-        
-        for child in ast.walk(node):
-            if isinstance(child, (ast.If, ast.While, ast.For, ast.AsyncFor)):
-                complexity += 1
-            elif isinstance(child, ast.ExceptHandler):
-                complexity += 1
-            elif isinstance(child, (ast.And, ast.Or)):
-                complexity += 1
-            elif isinstance(child, ast.comprehension):
-                complexity += 1
-        
-        return complexity
-    
-    def _has_type_hints(self, node: ast.FunctionDef) -> bool:
-        """Check if function has type hints."""
-        # Check return annotation
-        has_return_hint = node.returns is not None
-        
-        # Check parameter annotations
-        has_param_hints = any(arg.annotation is not None for arg in node.args.args)
-        
-        return has_return_hint or has_param_hints

django_cfg/modules/django_app_agent/services/validation_service/security_validator.py

@@ -1,272 +0,0 @@
-"""
-Security Validator for Django App Agent.
-
-This module validates security patterns and identifies potential
-security vulnerabilities in generated Django code.
-"""
-
-from typing import List, Dict, Any, Optional
-import ast
-import re
-
-from pydantic import BaseModel, Field
-
-from ...models.responses import GeneratedFile
-from ..base import ServiceDependencies
-from .models import ValidationIssue
-
-
-class SecurityValidator(BaseModel):
-    """Validates security patterns and identifies vulnerabilities."""
-    
-    security_rules: Dict[str, Dict[str, Any]] = Field(
-        default_factory=lambda: {
-            "sql_injection": {
-                "description": "Prevent SQL injection vulnerabilities",
-                "severity": "error"
-            },
-            "xss_protection": {
-                "description": "Ensure XSS protection in templates",
-                "severity": "error"
-            },
-            "csrf_protection": {
-                "description": "CSRF protection should be enabled",
-                "severity": "warning"
-            },
-            "secure_settings": {
-                "description": "Security settings should be properly configured",
-                "severity": "warning"
-            },
-            "input_validation": {
-                "description": "User input should be properly validated",
-                "severity": "warning"
-            },
-            "authentication_required": {
-                "description": "Sensitive views should require authentication",
-                "severity": "warning"
-            }
-        },
-        description="Security validation rules"
-    )
-
-    async def validate_security(
-        self,
-        file: GeneratedFile,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Validate security patterns for a single file."""
-        issues = []
-        
-        if file.file_type != "python":
-            return issues
-        
-        try:
-            tree = ast.parse(file.content)
-            
-            # Apply security checks
-            issues.extend(self._check_sql_injection(file, tree, dependencies))
-            issues.extend(self._check_authentication(file, tree, dependencies))
-            issues.extend(self._check_input_validation(file, tree, dependencies))
-            issues.extend(self._check_dangerous_functions(file, tree, dependencies))
-            
-        except SyntaxError:
-            # Skip security validation if syntax is invalid
-            pass
-        except Exception as e:
-            dependencies.log_error(f"Security validation failed for {file.path}", e)
-        
-        return issues
-    
-    def _check_sql_injection(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check for potential SQL injection vulnerabilities."""
-        issues = []
-        
-        # Look for raw SQL usage
-        for node in ast.walk(tree):
-            if isinstance(node, ast.Call):
-                # Check for raw() method calls
-                if (isinstance(node.func, ast.Attribute) and
-                    node.func.attr == "raw"):
-                    issues.append(ValidationIssue(
-                        severity="warning",
-                        category="security",
-                        message="Raw SQL query detected - ensure parameters are properly escaped",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="raw_sql_usage",
-                        suggestion="Use Django ORM or parameterized queries instead of raw SQL"
-                    ))
-                
-                # Check for extra() method with potentially unsafe parameters
-                if (isinstance(node.func, ast.Attribute) and
-                    node.func.attr == "extra"):
-                    issues.append(ValidationIssue(
-                        severity="warning",
-                        category="security",
-                        message="QuerySet.extra() usage detected - ensure SQL is safe",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="extra_sql_usage",
-                        suggestion="Prefer Django ORM methods over extra() when possible"
-                    ))
-        
-        # Check for string formatting in SQL-like contexts
-        content = file.content
-        if re.search(r'["\'].*%s.*["\'].*%', content):
-            issues.append(ValidationIssue(
-                severity="warning",
-                category="security",
-                message="String formatting in SQL-like context detected",
-                file_path=file.path,
-                line_number=1,
-                rule_id="string_format_sql",
-                suggestion="Use parameterized queries instead of string formatting"
-            ))
-        
-        return issues
-    
-    def _check_authentication(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check for proper authentication patterns."""
-        issues = []
-        
-        # Check views for authentication decorators/mixins
-        if "views.py" in file.path:
-            for node in ast.walk(tree):
-                if isinstance(node, ast.FunctionDef):
-                    # Check for authentication decorators
-                    has_auth_decorator = any(
-                        (isinstance(dec, ast.Name) and dec.id == "login_required") or
-                        (isinstance(dec, ast.Attribute) and dec.attr == "login_required")
-                        for dec in node.decorator_list
-                    )
-                    
-                    # Skip views that clearly don't need authentication
-                    if not has_auth_decorator and not self._is_public_view(node.name):
-                        issues.append(ValidationIssue(
-                            severity="info",
-                            category="security",
-                            message=f"View '{node.name}' may need authentication",
-                            file_path=file.path,
-                            line_number=node.lineno,
-                            rule_id="missing_authentication",
-                            suggestion=f"Consider adding @login_required decorator to {node.name} if it handles sensitive data"
-                        ))
-                
-                elif isinstance(node, ast.ClassDef):
-                    # Check class-based views for LoginRequiredMixin
-                    has_login_mixin = any(
-                        isinstance(base, ast.Name) and base.id == "LoginRequiredMixin"
-                        for base in node.bases
-                    )
-                    
-                    if not has_login_mixin and not self._is_public_view(node.name):
-                        issues.append(ValidationIssue(
-                            severity="info",
-                            category="security",
-                            message=f"View class '{node.name}' may need authentication",
-                            file_path=file.path,
-                            line_number=node.lineno,
-                            rule_id="missing_login_mixin",
-                            suggestion=f"Consider adding LoginRequiredMixin to {node.name} if it handles sensitive data"
-                        ))
-        
-        return issues
-    
-    def _check_input_validation(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check for proper input validation."""
-        issues = []
-        
-        # Check forms for validation methods
-        if "forms.py" in file.path:
-            for node in ast.walk(tree):
-                if isinstance(node, ast.ClassDef):
-                    is_form = any(
-                        isinstance(base, ast.Attribute) and
-                        base.attr in ["Form", "ModelForm"]
-                        for base in node.bases
-                    )
-                    
-                    if is_form:
-                        # Check for clean methods
-                        has_validation = any(
-                            isinstance(item, ast.FunctionDef) and
-                            (item.name.startswith("clean_") or item.name == "clean")
-                            for item in node.body
-                        )
-                        
-                        if not has_validation:
-                            issues.append(ValidationIssue(
-                                severity="info",
-                                category="security",
-                                message=f"Form '{node.name}' lacks custom validation",
-                                file_path=file.path,
-                                line_number=node.lineno,
-                                rule_id="missing_form_validation",
-                                suggestion=f"Consider adding clean_* methods to {node.name} for input validation"
-                            ))
-        
-        return issues
-    
-    def _check_dangerous_functions(
-        self,
-        file: GeneratedFile,
-        tree: ast.AST,
-        dependencies: ServiceDependencies
-    ) -> List[ValidationIssue]:
-        """Check for usage of potentially dangerous functions."""
-        issues = []
-        
-        dangerous_functions = {
-            "eval": "Use of eval() can execute arbitrary code",
-            "exec": "Use of exec() can execute arbitrary code", 
-            "compile": "Use of compile() with user input can be dangerous",
-            "__import__": "Dynamic imports can be security risks"
-        }
-        
-        for node in ast.walk(tree):
-            if isinstance(node, ast.Call):
-                func_name = None
-                
-                if isinstance(node.func, ast.Name):
-                    func_name = node.func.id
-                elif isinstance(node.func, ast.Attribute):
-                    func_name = node.func.attr
-                
-                if func_name in dangerous_functions:
-                    issues.append(ValidationIssue(
-                        severity="error",
-                        category="security",
-                        message=f"Dangerous function '{func_name}' detected: {dangerous_functions[func_name]}",
-                        file_path=file.path,
-                        line_number=node.lineno,
-                        rule_id="dangerous_function",
-                        suggestion=f"Avoid using {func_name}() or ensure input is properly sanitized"
-                    ))
-        
-        return issues
-    
-    def _is_public_view(self, view_name: str) -> bool:
-        """Check if a view is likely meant to be public."""
-        public_patterns = [
-            "index", "home", "landing", "about", "contact",
-            "login", "logout", "register", "signup",
-            "public", "api", "health", "status"
-        ]
-        
-        view_lower = view_name.lower()
-        return any(pattern in view_lower for pattern in public_patterns)