tapps-agents 3.6.0__py3-none-any.whl → 3.6.1__py3-none-any.whl

tapps_agents/core/evaluators/behavioral_evaluator.py

@@ -1,160 +1,160 @@
-"""
-Behavioral correctness evaluator.
-
-Validates that code behaves as it claims (logic flow analysis, contract validation).
-"""
-
-import ast
-import logging
-from pathlib import Path
-from typing import Any
-
-from ..evaluation_base import BaseEvaluator
-from ..evaluation_models import Issue, IssueCategory, IssueManifest, IssueSeverity
-
-logger = logging.getLogger(__name__)
-
-
-class BehavioralEvaluator(BaseEvaluator):
-    """
-    Evaluator for behavioral correctness validation.
-    
-    Uses AST-based logic flow analysis to detect potential behavioral issues.
-    """
-
-    def __init__(self):
-        """Initialize behavioral evaluator."""
-        pass
-
-    def get_name(self) -> str:
-        """Get evaluator name."""
-        return "behavioral"
-
-    def is_applicable(self, target: Path | str) -> bool:
-        """Check if evaluator can evaluate target (Python files only currently)."""
-        target_path = Path(target) if isinstance(target, str) else target
-        return target_path.suffix == ".py"
-
-    def evaluate(
-        self, target: Path | str, context: dict[str, Any] | None = None
-    ) -> IssueManifest:
-        """
-        Evaluate behavioral correctness.
-        
-        Args:
-            target: File path to evaluate
-            context: Optional context (code content, expected behavior, etc.)
-            
-        Returns:
-            IssueManifest with behavioral issues found
-        """
-        target_path = Path(target) if isinstance(target, str) else target
-        issues = IssueManifest()
-        
-        if not target_path.exists():
-            return issues
-        
-        try:
-            code = target_path.read_text(encoding="utf-8")
-            tree = ast.parse(code)
-            
-            # Analyze function contracts and logic flow
-            issues = self._analyze_logic_flow(tree, target_path, code)
-            
-        except SyntaxError as e:
-            # Syntax errors are critical behavioral issues
-            issue = Issue(
-                id=f"behavioral_syntax_{target_path.name}",
-                severity=IssueSeverity.CRITICAL,
-                category=IssueCategory.CORRECTNESS,
-                evidence=f"Syntax error in {target_path.name}: {e}",
-                repro=f"Run: python -m py_compile {target_path}",
-                suggested_fix="Fix syntax error: " + str(e),
-                owner_step="implementation",
-                file_path=str(target_path),
-                line_number=getattr(e, "lineno", None),
-            )
-            issues.add_issue(issue)
-        except Exception as e:
-            logger.warning(f"Error in behavioral evaluation of {target_path}: {e}")
-        
-        return issues
-
-    def _analyze_logic_flow(
-        self, tree: ast.AST, file_path: Path, code: str
-    ) -> IssueManifest:
-        """Analyze logic flow for potential behavioral issues."""
-        issues = IssueManifest()
-        
-        # Find functions
-        for node in ast.walk(tree):
-            if isinstance(node, ast.FunctionDef):
-                func_issues = self._analyze_function(node, file_path, code)
-                issues.add_issues(func_issues.issues)
-        
-        return issues
-
-    def _analyze_function(
-        self, func_node: ast.FunctionDef, file_path: Path, code: str
-    ) -> IssueManifest:
-        """Analyze a single function for behavioral issues."""
-        issues = IssueManifest()
-        
-        # Check for unreachable code
-        unreachable = self._find_unreachable_code(func_node)
-        for line_num in unreachable:
-            issue = Issue(
-                id=f"behavioral_unreachable_{func_node.name}_line_{line_num}",
-                severity=IssueSeverity.MEDIUM,
-                category=IssueCategory.CORRECTNESS,
-                evidence=f"Unreachable code in function {func_node.name} at line {line_num}",
-                repro=f"Inspect function {func_node.name} at line {line_num}",
-                suggested_fix="Remove unreachable code or fix control flow",
-                owner_step="implementation",
-                file_path=str(file_path),
-                line_number=line_num,
-            )
-            issues.add_issue(issue)
-        
-        # Check for missing return statements
-        if not self._has_return_statement(func_node):
-            # Check docstring for return type hint
-            docstring = ast.get_docstring(func_node)
-            if docstring and ("return" in docstring.lower() or "->" in docstring):
-                issue = Issue(
-                    id=f"behavioral_missing_return_{func_node.name}",
-                    severity=IssueSeverity.MEDIUM,
-                    category=IssueCategory.CORRECTNESS,
-                    evidence=f"Function {func_node.name} may be missing return statement (docstring indicates return type)",
-                    repro=f"Check function {func_node.name} return behavior",
-                    suggested_fix="Add return statement or update docstring",
-                    owner_step="implementation",
-                    file_path=str(file_path),
-                    line_number=func_node.lineno,
-                )
-                issues.add_issue(issue)
-        
-        return issues
-
-    def _find_unreachable_code(self, func_node: ast.FunctionDef) -> list[int]:
-        """Find unreachable code (after return/raise statements)."""
-        unreachable_lines: list[int] = []
-        returns_found = False
-        
-        for node in ast.walk(func_node):
-            if isinstance(node, (ast.Return, ast.Raise)):
-                returns_found = True
-                # Mark subsequent statements as potentially unreachable
-                # (simplified - full analysis would require control flow graph)
-                if hasattr(node, "lineno"):
-                    unreachable_lines.append(node.lineno + 1)
-        
-        return unreachable_lines if returns_found else []
-
-    def _has_return_statement(self, func_node: ast.FunctionDef) -> bool:
-        """Check if function has return statements."""
-        for node in ast.walk(func_node):
-            if isinstance(node, ast.Return):
-                return True
-        return False
-
+"""
+Behavioral correctness evaluator.
+
+Validates that code behaves as it claims (logic flow analysis, contract validation).
+"""
+
+import ast
+import logging
+from pathlib import Path
+from typing import Any
+
+from ..evaluation_base import BaseEvaluator
+from ..evaluation_models import Issue, IssueCategory, IssueManifest, IssueSeverity
+
+logger = logging.getLogger(__name__)
+
+
+class BehavioralEvaluator(BaseEvaluator):
+    """
+    Evaluator for behavioral correctness validation.
+    
+    Uses AST-based logic flow analysis to detect potential behavioral issues.
+    """
+
+    def __init__(self):
+        """Initialize behavioral evaluator."""
+        pass
+
+    def get_name(self) -> str:
+        """Get evaluator name."""
+        return "behavioral"
+
+    def is_applicable(self, target: Path | str) -> bool:
+        """Check if evaluator can evaluate target (Python files only currently)."""
+        target_path = Path(target) if isinstance(target, str) else target
+        return target_path.suffix == ".py"
+
+    def evaluate(
+        self, target: Path | str, context: dict[str, Any] | None = None
+    ) -> IssueManifest:
+        """
+        Evaluate behavioral correctness.
+        
+        Args:
+            target: File path to evaluate
+            context: Optional context (code content, expected behavior, etc.)
+            
+        Returns:
+            IssueManifest with behavioral issues found
+        """
+        target_path = Path(target) if isinstance(target, str) else target
+        issues = IssueManifest()
+        
+        if not target_path.exists():
+            return issues
+        
+        try:
+            code = target_path.read_text(encoding="utf-8")
+            tree = ast.parse(code)
+            
+            # Analyze function contracts and logic flow
+            issues = self._analyze_logic_flow(tree, target_path, code)
+            
+        except SyntaxError as e:
+            # Syntax errors are critical behavioral issues
+            issue = Issue(
+                id=f"behavioral_syntax_{target_path.name}",
+                severity=IssueSeverity.CRITICAL,
+                category=IssueCategory.CORRECTNESS,
+                evidence=f"Syntax error in {target_path.name}: {e}",
+                repro=f"Run: python -m py_compile {target_path}",
+                suggested_fix="Fix syntax error: " + str(e),
+                owner_step="implementation",
+                file_path=str(target_path),
+                line_number=getattr(e, "lineno", None),
+            )
+            issues.add_issue(issue)
+        except Exception as e:
+            logger.warning(f"Error in behavioral evaluation of {target_path}: {e}")
+        
+        return issues
+
+    def _analyze_logic_flow(
+        self, tree: ast.AST, file_path: Path, code: str
+    ) -> IssueManifest:
+        """Analyze logic flow for potential behavioral issues."""
+        issues = IssueManifest()
+        
+        # Find functions
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                func_issues = self._analyze_function(node, file_path, code)
+                issues.add_issues(func_issues.issues)
+        
+        return issues
+
+    def _analyze_function(
+        self, func_node: ast.FunctionDef, file_path: Path, code: str
+    ) -> IssueManifest:
+        """Analyze a single function for behavioral issues."""
+        issues = IssueManifest()
+        
+        # Check for unreachable code
+        unreachable = self._find_unreachable_code(func_node)
+        for line_num in unreachable:
+            issue = Issue(
+                id=f"behavioral_unreachable_{func_node.name}_line_{line_num}",
+                severity=IssueSeverity.MEDIUM,
+                category=IssueCategory.CORRECTNESS,
+                evidence=f"Unreachable code in function {func_node.name} at line {line_num}",
+                repro=f"Inspect function {func_node.name} at line {line_num}",
+                suggested_fix="Remove unreachable code or fix control flow",
+                owner_step="implementation",
+                file_path=str(file_path),
+                line_number=line_num,
+            )
+            issues.add_issue(issue)
+        
+        # Check for missing return statements
+        if not self._has_return_statement(func_node):
+            # Check docstring for return type hint
+            docstring = ast.get_docstring(func_node)
+            if docstring and ("return" in docstring.lower() or "->" in docstring):
+                issue = Issue(
+                    id=f"behavioral_missing_return_{func_node.name}",
+                    severity=IssueSeverity.MEDIUM,
+                    category=IssueCategory.CORRECTNESS,
+                    evidence=f"Function {func_node.name} may be missing return statement (docstring indicates return type)",
+                    repro=f"Check function {func_node.name} return behavior",
+                    suggested_fix="Add return statement or update docstring",
+                    owner_step="implementation",
+                    file_path=str(file_path),
+                    line_number=func_node.lineno,
+                )
+                issues.add_issue(issue)
+        
+        return issues
+
+    def _find_unreachable_code(self, func_node: ast.FunctionDef) -> list[int]:
+        """Find unreachable code (after return/raise statements)."""
+        unreachable_lines: list[int] = []
+        returns_found = False
+        
+        for node in ast.walk(func_node):
+            if isinstance(node, (ast.Return, ast.Raise)):
+                returns_found = True
+                # Mark subsequent statements as potentially unreachable
+                # (simplified - full analysis would require control flow graph)
+                if hasattr(node, "lineno"):
+                    unreachable_lines.append(node.lineno + 1)
+        
+        return unreachable_lines if returns_found else []
+
+    def _has_return_statement(self, func_node: ast.FunctionDef) -> bool:
+        """Check if function has return statements."""
+        for node in ast.walk(func_node):
+            if isinstance(node, ast.Return):
+                return True
+        return False
+

tapps_agents/core/evaluators/performance_profile_evaluator.py

@@ -1,160 +1,160 @@
-"""
-Performance profile evaluator.
-
-Identifies performance issues, bottlenecks, and resource usage patterns.
-"""
-
-import logging
-import re
-from pathlib import Path
-from typing import Any
-
-from ..evaluation_base import BaseEvaluator
-from ..evaluation_models import Issue, IssueCategory, IssueManifest, IssueSeverity
-
-logger = logging.getLogger(__name__)
-
-
-class PerformanceProfileEvaluator(BaseEvaluator):
-    """
-    Evaluator for performance profiling.
-    
-    Identifies performance anti-patterns and potential bottlenecks.
-    """
-
-    def __init__(self):
-        """Initialize performance profile evaluator."""
-        # Performance anti-patterns
-        self.anti_patterns = [
-            (r'for\s+\w+\s+in\s+\w+\.append\s*\(', "Inefficient list building - use list comprehension"),
-            (r'\.sort\s*\(\s*\)\s*.*\.sort\s*\(', "Multiple sorts - inefficient"),
-            (r'SELECT\s+\*\s+FROM', "SELECT * can be inefficient - specify columns"),
-            (r'nested\s+for\s+.*\s+for\s+', "Nested loops can be O(n²) or worse"),
-        ]
-
-    def get_name(self) -> str:
-        """Get evaluator name."""
-        return "performance_profile"
-
-    def is_applicable(self, target: Path | str) -> bool:
-        """Applicable to code files."""
-        target_path = Path(target) if isinstance(target, str) else target
-        return target_path.suffix in [".py", ".js", ".ts", ".tsx", ".jsx", ".sql"]
-
-    def evaluate(
-        self, target: Path | str, context: dict[str, Any] | None = None
-    ) -> IssueManifest:
-        """
-        Evaluate performance profile.
-        
-        Args:
-            target: File path to evaluate
-            context: Optional context
-            
-        Returns:
-            IssueManifest with performance issues found
-        """
-        target_path = Path(target) if isinstance(target, str) else target
-        issues = IssueManifest()
-        
-        if not target_path.exists() or not target_path.is_file():
-            return issues
-        
-        try:
-            code = target_path.read_text(encoding="utf-8")
-            
-            # Check for performance anti-patterns
-            for pattern, description in self.anti_patterns:
-                matches = list(re.finditer(pattern, code, re.IGNORECASE | re.MULTILINE))
-                for match in matches:
-                    line_num = code[:match.start()].count("\n") + 1
-                    
-                    issue = Issue(
-                        id=f"perf_anti_pattern_{line_num}",
-                        severity=IssueSeverity.LOW,
-                        category=IssueCategory.PERFORMANCE,
-                        evidence=f"Performance anti-pattern: {description}",
-                        repro=f"Inspect line {line_num} in {target_path}",
-                        suggested_fix=description,
-                        owner_step="implementation",
-                        file_path=str(target_path),
-                        line_number=line_num,
-                    )
-                    issues.add_issue(issue)
-            
-            # Check for nested loops (O(n²) complexity)
-            nested_loop_issues = self._check_nested_loops(code, target_path)
-            issues = issues.merge(nested_loop_issues)
-            
-            # Check for potential database N+1 queries
-            db_issues = self._check_database_queries(code, target_path)
-            issues = issues.merge(db_issues)
-            
-        except Exception as e:
-            logger.warning(f"Error in performance profile evaluation: {e}")
-        
-        return issues
-
-    def _check_nested_loops(
-        self, code: str, file_path: Path
-    ) -> IssueManifest:
-        """Check for deeply nested loops."""
-        issues = IssueManifest()
-        
-        # Count nested for/while loops
-        lines = code.splitlines()
-        for i, line in enumerate(lines, 1):
-            # Simple heuristic: count consecutive for/while statements
-            if i < len(lines) - 1:
-                current_line = line.strip()
-                next_line = lines[i].strip() if i < len(lines) else ""
-                
-                if re.match(r'for\s+', current_line) or re.match(r'while\s+', current_line):
-                    # Check if next line also has a loop (simplified)
-                    if re.match(r'for\s+', next_line) or re.match(r'while\s+', next_line):
-                        issue = Issue(
-                            id=f"perf_nested_loop_{i}",
-                            severity=IssueSeverity.MEDIUM,
-                            category=IssueCategory.PERFORMANCE,
-                            evidence=f"Nested loops detected at line {i} - potential O(n²) complexity",
-                            repro=f"Review nested loops in {file_path} around line {i}",
-                            suggested_fix="Consider optimizing nested loops or using vectorized operations",
-                            owner_step="implementation",
-                            file_path=str(file_path),
-                            line_number=i,
-                        )
-                        issues.add_issue(issue)
-        
-        return issues
-
-    def _check_database_queries(
-        self, code: str, file_path: Path
-    ) -> IssueManifest:
-        """Check for potential N+1 query patterns."""
-        issues = IssueManifest()
-        
-        # Check for loops containing queries (N+1 pattern)
-        query_patterns = [r'\.get\s*\(', r'\.filter\s*\(', r'SELECT\s+.*\s+FROM']
-        loop_pattern = r'for\s+\w+\s+in'
-        
-        if re.search(loop_pattern, code):
-            # Check if queries appear inside loops
-            # This is simplified - full analysis would require parsing control flow
-            for query_pattern in query_patterns:
-                if re.search(query_pattern, code, re.IGNORECASE):
-                    # Potential N+1 pattern
-                    issue = Issue(
-                        id=f"perf_n_plus_one_query",
-                        severity=IssueSeverity.MEDIUM,
-                        category=IssueCategory.PERFORMANCE,
-                        evidence="Potential N+1 query pattern: database queries inside loops",
-                        repro=f"Review {file_path} for queries inside loops",
-                        suggested_fix="Use bulk queries or eager loading to avoid N+1 queries",
-                        owner_step="implementation",
-                        file_path=str(file_path),
-                    )
-                    issues.add_issue(issue)
-                    break  # Only report once
-        
-        return issues
-
+"""
+Performance profile evaluator.
+
+Identifies performance issues, bottlenecks, and resource usage patterns.
+"""
+
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+from ..evaluation_base import BaseEvaluator
+from ..evaluation_models import Issue, IssueCategory, IssueManifest, IssueSeverity
+
+logger = logging.getLogger(__name__)
+
+
+class PerformanceProfileEvaluator(BaseEvaluator):
+    """
+    Evaluator for performance profiling.
+    
+    Identifies performance anti-patterns and potential bottlenecks.
+    """
+
+    def __init__(self):
+        """Initialize performance profile evaluator."""
+        # Performance anti-patterns
+        self.anti_patterns = [
+            (r'for\s+\w+\s+in\s+\w+\.append\s*\(', "Inefficient list building - use list comprehension"),
+            (r'\.sort\s*\(\s*\)\s*.*\.sort\s*\(', "Multiple sorts - inefficient"),
+            (r'SELECT\s+\*\s+FROM', "SELECT * can be inefficient - specify columns"),
+            (r'nested\s+for\s+.*\s+for\s+', "Nested loops can be O(n²) or worse"),
+        ]
+
+    def get_name(self) -> str:
+        """Get evaluator name."""
+        return "performance_profile"
+
+    def is_applicable(self, target: Path | str) -> bool:
+        """Applicable to code files."""
+        target_path = Path(target) if isinstance(target, str) else target
+        return target_path.suffix in [".py", ".js", ".ts", ".tsx", ".jsx", ".sql"]
+
+    def evaluate(
+        self, target: Path | str, context: dict[str, Any] | None = None
+    ) -> IssueManifest:
+        """
+        Evaluate performance profile.
+        
+        Args:
+            target: File path to evaluate
+            context: Optional context
+            
+        Returns:
+            IssueManifest with performance issues found
+        """
+        target_path = Path(target) if isinstance(target, str) else target
+        issues = IssueManifest()
+        
+        if not target_path.exists() or not target_path.is_file():
+            return issues
+        
+        try:
+            code = target_path.read_text(encoding="utf-8")
+            
+            # Check for performance anti-patterns
+            for pattern, description in self.anti_patterns:
+                matches = list(re.finditer(pattern, code, re.IGNORECASE | re.MULTILINE))
+                for match in matches:
+                    line_num = code[:match.start()].count("\n") + 1
+                    
+                    issue = Issue(
+                        id=f"perf_anti_pattern_{line_num}",
+                        severity=IssueSeverity.LOW,
+                        category=IssueCategory.PERFORMANCE,
+                        evidence=f"Performance anti-pattern: {description}",
+                        repro=f"Inspect line {line_num} in {target_path}",
+                        suggested_fix=description,
+                        owner_step="implementation",
+                        file_path=str(target_path),
+                        line_number=line_num,
+                    )
+                    issues.add_issue(issue)
+            
+            # Check for nested loops (O(n²) complexity)
+            nested_loop_issues = self._check_nested_loops(code, target_path)
+            issues = issues.merge(nested_loop_issues)
+            
+            # Check for potential database N+1 queries
+            db_issues = self._check_database_queries(code, target_path)
+            issues = issues.merge(db_issues)
+            
+        except Exception as e:
+            logger.warning(f"Error in performance profile evaluation: {e}")
+        
+        return issues
+
+    def _check_nested_loops(
+        self, code: str, file_path: Path
+    ) -> IssueManifest:
+        """Check for deeply nested loops."""
+        issues = IssueManifest()
+        
+        # Count nested for/while loops
+        lines = code.splitlines()
+        for i, line in enumerate(lines, 1):
+            # Simple heuristic: count consecutive for/while statements
+            if i < len(lines) - 1:
+                current_line = line.strip()
+                next_line = lines[i].strip() if i < len(lines) else ""
+                
+                if re.match(r'for\s+', current_line) or re.match(r'while\s+', current_line):
+                    # Check if next line also has a loop (simplified)
+                    if re.match(r'for\s+', next_line) or re.match(r'while\s+', next_line):
+                        issue = Issue(
+                            id=f"perf_nested_loop_{i}",
+                            severity=IssueSeverity.MEDIUM,
+                            category=IssueCategory.PERFORMANCE,
+                            evidence=f"Nested loops detected at line {i} - potential O(n²) complexity",
+                            repro=f"Review nested loops in {file_path} around line {i}",
+                            suggested_fix="Consider optimizing nested loops or using vectorized operations",
+                            owner_step="implementation",
+                            file_path=str(file_path),
+                            line_number=i,
+                        )
+                        issues.add_issue(issue)
+        
+        return issues
+
+    def _check_database_queries(
+        self, code: str, file_path: Path
+    ) -> IssueManifest:
+        """Check for potential N+1 query patterns."""
+        issues = IssueManifest()
+        
+        # Check for loops containing queries (N+1 pattern)
+        query_patterns = [r'\.get\s*\(', r'\.filter\s*\(', r'SELECT\s+.*\s+FROM']
+        loop_pattern = r'for\s+\w+\s+in'
+        
+        if re.search(loop_pattern, code):
+            # Check if queries appear inside loops
+            # This is simplified - full analysis would require parsing control flow
+            for query_pattern in query_patterns:
+                if re.search(query_pattern, code, re.IGNORECASE):
+                    # Potential N+1 pattern
+                    issue = Issue(
+                        id=f"perf_n_plus_one_query",
+                        severity=IssueSeverity.MEDIUM,
+                        category=IssueCategory.PERFORMANCE,
+                        evidence="Potential N+1 query pattern: database queries inside loops",
+                        repro=f"Review {file_path} for queries inside loops",
+                        suggested_fix="Use bulk queries or eager loading to avoid N+1 queries",
+                        owner_step="implementation",
+                        file_path=str(file_path),
+                    )
+                    issues.add_issue(issue)
+                    break  # Only report once
+        
+        return issues
+