empathy-framework 5.1.1__py3-none-any.whl → 5.3.0__py3-none-any.whl

empathy_os/workflows/test_gen/ast_analyzer.py

@@ -0,0 +1,249 @@
+"""AST-based Function and Class Analyzer.
+
+Extracts function signatures, exception types, side effects, and complexity
+from Python source code using AST parsing.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import ast
+
+from .data_models import ClassSignature, FunctionSignature
+
+
+class ASTFunctionAnalyzer(ast.NodeVisitor):
+    """AST-based function analyzer for accurate test generation.
+
+    Extracts:
+    - Function signatures with types
+    - Exception types raised
+    - Side effects detection
+    - Complexity estimation
+
+    Parse errors are tracked in the `last_error` attribute for debugging.
+    """
+
+    def __init__(self):
+        self.functions: list[FunctionSignature] = []
+        self.classes: list[ClassSignature] = []
+        self._current_class: str | None = None
+        self.last_error: str | None = None  # Track parse errors for debugging
+
+    def analyze(
+        self,
+        code: str,
+        file_path: str = "",
+    ) -> tuple[list[FunctionSignature], list[ClassSignature]]:
+        """Analyze code and extract function/class signatures.
+
+        Args:
+            code: Python source code to analyze
+            file_path: Optional file path for error reporting
+
+        Returns:
+            Tuple of (functions, classes) lists. If parsing fails,
+            returns empty lists and sets self.last_error with details.
+
+        """
+        self.last_error = None
+        try:
+            tree = ast.parse(code)
+            self.functions = []
+            self.classes = []
+            self.visit(tree)
+            return self.functions, self.classes
+        except SyntaxError as e:
+            # Track the error for debugging instead of silent failure
+            location = f" at line {e.lineno}" if e.lineno else ""
+            file_info = f" in {file_path}" if file_path else ""
+            self.last_error = f"SyntaxError{file_info}{location}: {e.msg}"
+            return [], []
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """Extract function signature."""
+        if self._current_class is None:  # Only top-level functions
+            sig = self._extract_function_signature(node)
+            self.functions.append(sig)
+            # Don't visit nested functions - we only want top-level
+        else:
+            # Inside a class - this is a method, visit it
+            self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Extract async function signature."""
+        if self._current_class is None:
+            sig = self._extract_function_signature(node, is_async=True)
+            self.functions.append(sig)
+            # Don't visit nested functions - we only want top-level
+        else:
+            # Inside a class - this is a method, visit it
+            self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        """Extract class signature with methods."""
+        self._current_class = node.name
+        methods = []
+        init_params: list[tuple[str, str, str | None]] = []
+
+        # Extract base classes
+        base_classes = []
+        for base in node.bases:
+            if isinstance(base, ast.Name):
+                base_classes.append(base.id)
+            elif isinstance(base, ast.Attribute):
+                base_classes.append(ast.unparse(base))
+
+        # Detect if this is an Enum
+        enum_bases = {"Enum", "IntEnum", "StrEnum", "Flag", "IntFlag", "auto"}
+        is_enum = any(b in enum_bases for b in base_classes)
+
+        # Detect if this is a dataclass
+        is_dataclass = False
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name) and decorator.id == "dataclass":
+                is_dataclass = True
+            elif isinstance(decorator, ast.Call):
+                if isinstance(decorator.func, ast.Name) and decorator.func.id == "dataclass":
+                    is_dataclass = True
+
+        # Process methods
+        for item in node.body:
+            if isinstance(item, ast.FunctionDef | ast.AsyncFunctionDef):
+                method_sig = self._extract_function_signature(
+                    item,
+                    is_async=isinstance(item, ast.AsyncFunctionDef),
+                )
+                methods.append(method_sig)
+
+                # Extract __init__ params
+                if item.name == "__init__":
+                    init_params = method_sig.params[1:]  # Skip 'self'
+
+        # Count required init params (those without defaults)
+        required_init_params = sum(1 for p in init_params if p[2] is None)
+
+        self.classes.append(
+            ClassSignature(
+                name=node.name,
+                methods=methods,
+                init_params=init_params,
+                base_classes=base_classes,
+                docstring=ast.get_docstring(node),
+                is_enum=is_enum,
+                is_dataclass=is_dataclass,
+                required_init_params=required_init_params,
+            ),
+        )
+
+        self._current_class = None
+        # Don't call generic_visit to avoid processing methods again
+
+    def _extract_function_signature(
+        self,
+        node: ast.FunctionDef | ast.AsyncFunctionDef,
+        is_async: bool = False,
+    ) -> FunctionSignature:
+        """Extract detailed signature from function node."""
+        # Extract parameters with types and defaults
+        params = []
+        defaults = list(node.args.defaults)
+        num_defaults = len(defaults)
+        num_args = len(node.args.args)
+
+        for i, arg in enumerate(node.args.args):
+            param_name = arg.arg
+            param_type = ast.unparse(arg.annotation) if arg.annotation else "Any"
+
+            # Calculate default index
+            default_idx = i - (num_args - num_defaults)
+            default_val = None
+            if default_idx >= 0:
+                try:
+                    default_val = ast.unparse(defaults[default_idx])
+                except Exception:
+                    default_val = "..."
+
+            params.append((param_name, param_type, default_val))
+
+        # Extract return type
+        return_type = ast.unparse(node.returns) if node.returns else None
+
+        # Find raised exceptions
+        raises: set[str] = set()
+        for child in ast.walk(node):
+            if isinstance(child, ast.Raise) and child.exc:
+                if isinstance(child.exc, ast.Call):
+                    if isinstance(child.exc.func, ast.Name):
+                        raises.add(child.exc.func.id)
+                    elif isinstance(child.exc.func, ast.Attribute):
+                        raises.add(child.exc.func.attr)
+                elif isinstance(child.exc, ast.Name):
+                    raises.add(child.exc.id)
+
+        # Detect side effects (simple heuristic)
+        has_side_effects = self._detect_side_effects(node)
+
+        # Estimate complexity
+        complexity = self._estimate_complexity(node)
+
+        # Extract decorators
+        decorators = []
+        for dec in node.decorator_list:
+            if isinstance(dec, ast.Name):
+                decorators.append(dec.id)
+            elif isinstance(dec, ast.Attribute):
+                decorators.append(ast.unparse(dec))
+            elif isinstance(dec, ast.Call):
+                if isinstance(dec.func, ast.Name):
+                    decorators.append(dec.func.id)
+
+        return FunctionSignature(
+            name=node.name,
+            params=params,
+            return_type=return_type,
+            is_async=is_async or isinstance(node, ast.AsyncFunctionDef),
+            raises=raises,
+            has_side_effects=has_side_effects,
+            docstring=ast.get_docstring(node),
+            complexity=complexity,
+            decorators=decorators,
+        )
+
+    def _detect_side_effects(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+        """Detect if function has side effects (writes to files, global state, etc.)."""
+        side_effect_names = {
+            "print",
+            "write",
+            "open",
+            "save",
+            "delete",
+            "remove",
+            "update",
+            "insert",
+            "execute",
+            "send",
+            "post",
+            "put",
+            "patch",
+        }
+
+        for child in ast.walk(node):
+            if isinstance(child, ast.Call):
+                if isinstance(child.func, ast.Name):
+                    if child.func.id.lower() in side_effect_names:
+                        return True
+                elif isinstance(child.func, ast.Attribute):
+                    if child.func.attr.lower() in side_effect_names:
+                        return True
+        return False
+
+    def _estimate_complexity(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> int:
+        """Estimate cyclomatic complexity (simplified)."""
+        complexity = 1
+        for child in ast.walk(node):
+            if isinstance(child, ast.If | ast.While | ast.For | ast.ExceptHandler):
+                complexity += 1
+            elif isinstance(child, ast.BoolOp):
+                complexity += len(child.values) - 1
+        return complexity

empathy_os/workflows/test_gen/config.py

@@ -0,0 +1,88 @@
+"""Test Generation Configuration.
+
+Default patterns and step configurations for test generation workflow.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..step_config import WorkflowStepConfig
+
+# =============================================================================
+# Default Configuration
+# =============================================================================
+
+# Directories to skip during file scanning (configurable via input_data["skip_patterns"])
+DEFAULT_SKIP_PATTERNS = [
+    # Version control
+    ".git",
+    ".hg",
+    ".svn",
+    # Dependencies
+    "node_modules",
+    "bower_components",
+    "vendor",
+    # Python caches
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".hypothesis",
+    # Virtual environments
+    "venv",
+    ".venv",
+    "env",
+    ".env",
+    "virtualenv",
+    ".virtualenv",
+    # Build tools
+    ".tox",
+    ".nox",
+    # Build outputs
+    "build",
+    "dist",
+    "eggs",
+    ".eggs",
+    "site-packages",
+    # IDE
+    ".idea",
+    ".vscode",
+    # Framework-specific
+    "migrations",
+    "alembic",
+    # Documentation
+    "_build",
+    "docs/_build",
+]
+
+# Define step configurations for executor-based execution
+TEST_GEN_STEPS = {
+    "identify": WorkflowStepConfig(
+        name="identify",
+        task_type="triage",  # Cheap tier task
+        tier_hint="cheap",
+        description="Identify files needing tests",
+        max_tokens=2000,
+    ),
+    "analyze": WorkflowStepConfig(
+        name="analyze",
+        task_type="code_analysis",  # Capable tier task
+        tier_hint="capable",
+        description="Analyze code structure for test generation",
+        max_tokens=3000,
+    ),
+    "generate": WorkflowStepConfig(
+        name="generate",
+        task_type="code_generation",  # Capable tier task
+        tier_hint="capable",
+        description="Generate test cases",
+        max_tokens=4000,
+    ),
+    "review": WorkflowStepConfig(
+        name="review",
+        task_type="final_review",  # Premium tier task
+        tier_hint="premium",
+        description="Review and improve generated test suite",
+        max_tokens=3000,
+    ),
+}

empathy_os/workflows/test_gen/data_models.py

@@ -0,0 +1,38 @@
+"""Test Generation Data Models.
+
+Dataclass definitions for function and class signatures.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class FunctionSignature:
+    """Detailed function analysis for test generation."""
+
+    name: str
+    params: list[tuple[str, str, str | None]]  # (name, type_hint, default)
+    return_type: str | None
+    is_async: bool
+    raises: set[str]
+    has_side_effects: bool
+    docstring: str | None
+    complexity: int = 1  # Rough complexity estimate
+    decorators: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ClassSignature:
+    """Detailed class analysis for test generation."""
+
+    name: str
+    methods: list[FunctionSignature]
+    init_params: list[tuple[str, str, str | None]]  # Constructor params
+    base_classes: list[str]
+    docstring: str | None
+    is_enum: bool = False  # True if class inherits from Enum
+    is_dataclass: bool = False  # True if class has @dataclass decorator
+    required_init_params: int = 0  # Number of params without defaults

empathy_os/workflows/test_gen/report_formatter.py

@@ -0,0 +1,289 @@
+"""Test Generation Report Formatter.
+
+Format test generation output as human-readable reports.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import re
+
+
+def format_test_gen_report(result: dict, input_data: dict) -> str:
+    """Format test generation output as a human-readable report.
+
+    Args:
+        result: The review stage result
+        input_data: Input data from previous stages
+
+    Returns:
+        Formatted report string
+
+    """
+    lines = []
+
+    # Header
+    total_tests = result.get("total_tests", 0)
+    files_covered = result.get("files_covered", 0)
+
+    lines.append("=" * 60)
+    lines.append("TEST GAP ANALYSIS REPORT")
+    lines.append("=" * 60)
+    lines.append("")
+
+    # Summary stats
+    total_candidates = input_data.get("total_candidates", 0)
+    hotspot_count = input_data.get("hotspot_count", 0)
+    untested_count = input_data.get("untested_count", 0)
+
+    lines.append("-" * 60)
+    lines.append("SUMMARY")
+    lines.append("-" * 60)
+    lines.append(f"Tests Generated:     {total_tests}")
+    lines.append(f"Files Covered:       {files_covered}")
+    lines.append(f"Total Candidates:    {total_candidates}")
+    lines.append(f"Bug Hotspots Found:  {hotspot_count}")
+    lines.append(f"Untested Files:      {untested_count}")
+    lines.append("")
+
+    # Status indicator
+    if total_tests == 0:
+        lines.append("⚠️  No tests were generated")
+    elif total_tests < 5:
+        lines.append(f"🟡 Generated {total_tests} test(s) - consider adding more coverage")
+    elif total_tests < 20:
+        lines.append(f"🟢 Generated {total_tests} tests - good coverage")
+    else:
+        lines.append(f"✅ Generated {total_tests} tests - excellent coverage")
+    lines.append("")
+
+    # Scope notice for enterprise clarity
+    total_source = input_data.get("total_source_files", 0)
+    existing_tests = input_data.get("existing_test_files", 0)
+    coverage_pct = input_data.get("analysis_coverage_percent", 100)
+    large_project = input_data.get("large_project_warning", False)
+
+    if total_source > 0 or existing_tests > 0:
+        lines.append("-" * 60)
+        lines.append("SCOPE NOTICE")
+        lines.append("-" * 60)
+
+        if large_project:
+            lines.append("⚠️  LARGE PROJECT: Only high-priority files analyzed")
+            lines.append(f"   Coverage: {coverage_pct:.0f}% of candidate files")
+            lines.append("")
+
+        lines.append(f"Source Files Found:   {total_source}")
+        lines.append(f"Existing Test Files:  {existing_tests}")
+        lines.append(f"Files Analyzed:       {files_covered}")
+
+        if existing_tests > 0:
+            lines.append("")
+            lines.append("Note: This report identifies gaps in untested files.")
+            lines.append("Run 'pytest --co -q' for full test suite statistics.")
+        lines.append("")
+
+    # Parse XML review feedback if present
+    review = result.get("review_feedback", "")
+    xml_summary = ""
+    xml_findings = []
+    xml_tests = []
+    coverage_improvement = ""
+
+    if review and "<response>" in review:
+        # Extract summary
+        summary_match = re.search(r"<summary>(.*?)</summary>", review, re.DOTALL)
+        if summary_match:
+            xml_summary = summary_match.group(1).strip()
+
+        # Extract coverage improvement
+        coverage_match = re.search(
+            r"<coverage-improvement>(.*?)</coverage-improvement>",
+            review,
+            re.DOTALL,
+        )
+        if coverage_match:
+            coverage_improvement = coverage_match.group(1).strip()
+
+        # Extract findings
+        for finding_match in re.finditer(
+            r'<finding severity="(\w+)">(.*?)</finding>',
+            review,
+            re.DOTALL,
+        ):
+            severity = finding_match.group(1)
+            finding_content = finding_match.group(2)
+
+            title_match = re.search(r"<title>(.*?)</title>", finding_content, re.DOTALL)
+            location_match = re.search(r"<location>(.*?)</location>", finding_content, re.DOTALL)
+            fix_match = re.search(r"<fix>(.*?)</fix>", finding_content, re.DOTALL)
+
+            xml_findings.append(
+                {
+                    "severity": severity,
+                    "title": title_match.group(1).strip() if title_match else "Unknown",
+                    "location": location_match.group(1).strip() if location_match else "",
+                    "fix": fix_match.group(1).strip() if fix_match else "",
+                },
+            )
+
+        # Extract suggested tests
+        for test_match in re.finditer(r'<test target="([^"]+)">(.*?)</test>', review, re.DOTALL):
+            target = test_match.group(1)
+            test_content = test_match.group(2)
+
+            type_match = re.search(r"<type>(.*?)</type>", test_content, re.DOTALL)
+            desc_match = re.search(r"<description>(.*?)</description>", test_content, re.DOTALL)
+
+            xml_tests.append(
+                {
+                    "target": target,
+                    "type": type_match.group(1).strip() if type_match else "unit",
+                    "description": desc_match.group(1).strip() if desc_match else "",
+                },
+            )
+
+    # Show parsed summary
+    if xml_summary:
+        lines.append("-" * 60)
+        lines.append("QUALITY ASSESSMENT")
+        lines.append("-" * 60)
+        # Word wrap the summary
+        words = xml_summary.split()
+        current_line = ""
+        for word in words:
+            if len(current_line) + len(word) + 1 <= 58:
+                current_line += (" " if current_line else "") + word
+            else:
+                lines.append(current_line)
+                current_line = word
+        if current_line:
+            lines.append(current_line)
+        lines.append("")
+
+        if coverage_improvement:
+            lines.append(f"📈 {coverage_improvement}")
+            lines.append("")
+
+    # Show findings by severity
+    if xml_findings:
+        lines.append("-" * 60)
+        lines.append("QUALITY FINDINGS")
+        lines.append("-" * 60)
+
+        severity_emoji = {"high": "🔴", "medium": "🟠", "low": "🟡", "info": "🔵"}
+        severity_order = {"high": 0, "medium": 1, "low": 2, "info": 3}
+
+        sorted_findings = sorted(xml_findings, key=lambda f: severity_order.get(f["severity"], 4))
+
+        for finding in sorted_findings:
+            emoji = severity_emoji.get(finding["severity"], "⚪")
+            lines.append(f"{emoji} [{finding['severity'].upper()}] {finding['title']}")
+            if finding["location"]:
+                lines.append(f"   Location: {finding['location']}")
+            if finding["fix"]:
+                # Truncate long fix recommendations
+                fix_text = finding["fix"]
+                if len(fix_text) > 70:
+                    fix_text = fix_text[:67] + "..."
+                lines.append(f"   Fix: {fix_text}")
+            lines.append("")
+
+    # Show suggested tests
+    if xml_tests:
+        lines.append("-" * 60)
+        lines.append("SUGGESTED TESTS TO ADD")
+        lines.append("-" * 60)
+
+        for i, test in enumerate(xml_tests[:5], 1):  # Limit to 5
+            lines.append(f"{i}. {test['target']} ({test['type']})")
+            if test["description"]:
+                desc = test["description"]
+                if len(desc) > 55:
+                    desc = desc[:52] + "..."
+                lines.append(f"   {desc}")
+            lines.append("")
+
+        if len(xml_tests) > 5:
+            lines.append(f"   ... and {len(xml_tests) - 5} more suggested tests")
+            lines.append("")
+
+    # Generated tests breakdown (if no XML data)
+    generated_tests = input_data.get("generated_tests", [])
+    if generated_tests and not xml_findings:
+        lines.append("-" * 60)
+        lines.append("GENERATED TESTS BY FILE")
+        lines.append("-" * 60)
+        for test_file in generated_tests[:10]:  # Limit display
+            source = test_file.get("source_file", "unknown")
+            test_count = test_file.get("test_count", 0)
+            # Shorten path for display
+            if len(source) > 50:
+                source = "..." + source[-47:]
+            lines.append(f"  📁 {source}")
+            lines.append(
+                f"     └─ {test_count} test(s) → {test_file.get('test_file', 'test_*.py')}",
+            )
+        if len(generated_tests) > 10:
+            lines.append(f"  ... and {len(generated_tests) - 10} more files")
+        lines.append("")
+
+    # Written files section
+    written_files = input_data.get("written_files", [])
+    if written_files:
+        lines.append("-" * 60)
+        lines.append("TESTS WRITTEN TO DISK")
+        lines.append("-" * 60)
+        for file_path in written_files[:10]:
+            # Shorten path for display
+            if len(file_path) > 55:
+                file_path = "..." + file_path[-52:]
+            lines.append(f"  ✅ {file_path}")
+        if len(written_files) > 10:
+            lines.append(f"  ... and {len(written_files) - 10} more files")
+        lines.append("")
+        lines.append("  Run: pytest <file> to execute these tests")
+        lines.append("")
+    elif input_data.get("tests_written") is False and total_tests > 0:
+        lines.append("-" * 60)
+        lines.append("GENERATED TESTS (NOT WRITTEN)")
+        lines.append("-" * 60)
+        lines.append("  ⚠️  Tests were generated but not written to disk.")
+        lines.append("  To write tests, run with: write_tests=True")
+        lines.append("")
+
+    # Recommendations
+    lines.append("-" * 60)
+    lines.append("NEXT STEPS")
+    lines.append("-" * 60)
+
+    high_findings = sum(1 for f in xml_findings if f["severity"] == "high")
+    medium_findings = sum(1 for f in xml_findings if f["severity"] == "medium")
+
+    if high_findings > 0:
+        lines.append(f"  🔴 Address {high_findings} high-priority finding(s) first")
+
+    if medium_findings > 0:
+        lines.append(f"  🟠 Review {medium_findings} medium-priority finding(s)")
+
+    if xml_tests:
+        lines.append(f"  📝 Consider adding {len(xml_tests)} suggested test(s)")
+
+    if hotspot_count > 0:
+        lines.append(f"  🔥 {hotspot_count} bug hotspot file(s) need priority testing")
+
+    if untested_count > 0:
+        lines.append(f"  📁 {untested_count} file(s) have no existing tests")
+
+    if not any([high_findings, medium_findings, xml_tests, hotspot_count, untested_count]):
+        lines.append("  ✅ Test suite is in good shape!")
+
+    lines.append("")
+
+    # Footer
+    lines.append("=" * 60)
+    model_tier = result.get("model_tier_used", "unknown")
+    lines.append(f"Review completed using {model_tier} tier model")
+    lines.append("=" * 60)
+
+    return "\n".join(lines)