core-runtime 0.1.1__py3-none-any.whl

body/self_healing/test_context/formatter.py

@@ -0,0 +1,65 @@
+# src/body/self_healing/test_context/formatter.py
+
+"""Provides functionality for the formatter module."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from .models import ModuleContext
+
+
+# ID: 02560995-d66d-493d-8896-138a623a8304
+def format_to_prompt(ctx: ModuleContext) -> str:
+    """Convert context to formatted string for LLM prompt."""
+    lines = [
+        "# MODULE CONTEXT",
+        f"\n## Module: {ctx.module_path}",
+        f"Import as: `{ctx.import_path}`",
+    ]
+    if ctx.module_docstring:
+        lines.extend(["\n## Purpose", ctx.module_docstring])
+
+    lines.extend(
+        ["\n## Coverage Status", f"Current Coverage: {ctx.current_coverage:.1f}%"]
+    )
+    if ctx.uncovered_functions:
+        lines.append(f"Uncovered Functions ({len(ctx.uncovered_functions)}):")
+        for func in ctx.uncovered_functions[:10]:
+            lines.append(f"  - {func}")
+
+    lines.append("\n## Module Structure")
+    for cls in ctx.classes:
+        lines.append(
+            f"  - {cls['name']}: {cls.get('docstring', 'No description')[:80]}"
+        )
+    for func in ctx.functions:
+        lines.append(
+            f"  - {func['name']}: {func.get('docstring', 'No description')[:80]}"
+        )
+
+    lines.append("\n## Dependencies to Mock")
+    if ctx.external_deps:
+        lines.append("External dependencies that MUST be mocked:")
+        for dep in ctx.external_deps:
+            lines.append(f"  - {dep}")
+
+    if ctx.filesystem_usage:
+        lines.append(
+            "⚠️  This module uses filesystem operations - use tmp_path fixture!"
+        )
+    if ctx.database_usage:
+        lines.append("⚠️  This module uses database - mock get_session()!")
+    if ctx.network_usage:
+        lines.append("⚠️  This module uses network - mock httpx requests!")
+
+    if ctx.similar_test_files:
+        lines.append("\n## Example Test Patterns from Similar Modules")
+        for ex in ctx.similar_test_files[:2]:
+            lines.extend(
+                [f"\n### Example from {ex['file']}", "```python", ex["snippet"], "```"]
+            )
+
+    return "\n".join(lines)

body/self_healing/test_context/metrics.py

@@ -0,0 +1,62 @@
+# src/body/self_healing/test_context/metrics.py
+
+"""Refactored logic for src/features/self_healing/test_context/metrics.py."""
+
+from __future__ import annotations
+
+import ast
+import json
+import subprocess
+from pathlib import Path
+
+from shared.infrastructure.intent.operational_config import load_operational_config
+
+
+_CFG = load_operational_config().testing
+
+
+# ID: d5f0e7e2-e4aa-442c-8128-4bc8f6a95984
+def get_coverage_data(repo_root: Path, module_path: str) -> dict:
+    try:
+        subprocess.run(
+            ["pytest", f"--cov={repo_root}/src", "--cov-report=json", "-q"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            timeout=_CFG.metrics_timeout_sec,
+        )
+        cov_file = repo_root / "coverage.json"
+        if cov_file.exists():
+            data = json.loads(cov_file.read_text())
+            file_key = str(repo_root / module_path)
+            if file_key in data.get("files", {}):
+                f_data = data["files"][file_key]
+                uncovered = f_data.get("missing_lines", [])
+                total = f_data.get("summary", {}).get("num_statements", 1)
+                covered = f_data.get("summary", {}).get("covered_lines", 0)
+                return {
+                    "coverage": covered / total * 100,
+                    "uncovered_lines": uncovered,
+                    "uncovered_functions": map_lines_to_funcs(
+                        repo_root / module_path, uncovered
+                    ),
+                }
+    except Exception:
+        pass
+    return {"coverage": 0.0, "uncovered_lines": [], "uncovered_functions": []}
+
+
+# ID: fa5f4fe3-e9c2-4946-b3f2-6fd85cf141ab
+def map_lines_to_funcs(file_path: Path, lines: list[int]) -> list[str]:
+    try:
+        tree = ast.parse(file_path.read_text(encoding="utf-8"))
+        return list(
+            {
+                n.name
+                for n in ast.walk(tree)
+                if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+                and any(n.lineno <= ln <= (n.end_lineno or n.lineno) for ln in lines)
+            }
+        )
+    except Exception:
+        return []

body/self_healing/test_context/models.py

@@ -0,0 +1,83 @@
+# src/body/self_healing/test_context/models.py
+
+"""Provides functionality for the models module."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+# ID: 8dde3ec5-ce2c-4486-b6d7-7751ceaabfd0
+class ModuleContext:
+    """Rich context about a module for test generation."""
+
+    module_path: str
+    module_name: str
+    import_path: str
+    source_code: str
+    module_docstring: str | None
+    classes: list[dict[str, Any]]
+    functions: list[dict[str, Any]]
+    imports: list[str]
+    dependencies: list[str]
+    current_coverage: float
+    uncovered_lines: list[int]
+    uncovered_functions: list[str]
+    similar_test_files: list[dict[str, Any]]
+    external_deps: list[str]
+    filesystem_usage: bool
+    database_usage: bool
+    network_usage: bool
+
+    # ID: 3f98af1c-2f9f-4057-8825-d4823445552d
+    def to_prompt_context(self) -> str:
+        """Convert to formatted context for LLM prompt."""
+        lines = []
+        lines.append("# MODULE CONTEXT")
+        lines.append(f"\n## Module: {self.module_path}")
+        lines.append(f"Import as: `{self.import_path}`")
+        if self.module_docstring:
+            lines.append("\n## Purpose")
+            lines.append(self.module_docstring)
+        lines.append("\n## Coverage Status")
+        lines.append(f"Current Coverage: {self.current_coverage:.1f}%")
+        if self.uncovered_functions:
+            lines.append(f"Uncovered Functions ({len(self.uncovered_functions)}):")
+            for func in self.uncovered_functions[:10]:
+                lines.append(f"  - {func}")
+        lines.append("\n## Module Structure")
+        if self.classes:
+            lines.append(f"Classes ({len(self.classes)}):")
+            for cls in self.classes:
+                lines.append(
+                    f"  - {cls['name']}: {cls.get('docstring', 'No description')[:80]}"
+                )
+        if self.functions:
+            lines.append(f"Functions ({len(self.functions)}):")
+            for func in self.functions:
+                lines.append(
+                    f"  - {func['name']}: {func.get('docstring', 'No description')[:80]}"
+                )
+        lines.append("\n## Dependencies to Mock")
+        if self.external_deps:
+            lines.append("External dependencies that MUST be mocked:")
+            for dep in self.external_deps:
+                lines.append(f"  - {dep}")
+        if self.filesystem_usage:
+            lines.append(
+                "⚠️  This module uses filesystem operations - use tmp_path fixture!"
+            )
+        if self.database_usage:
+            lines.append("⚠️  This module uses database - mock get_session()!")
+        if self.network_usage:
+            lines.append("⚠️  This module uses network - mock httpx requests!")
+        if self.similar_test_files:
+            lines.append("\n## Example Test Patterns from Similar Modules")
+            for example in self.similar_test_files[:2]:
+                lines.append(f"\n### Example from {example['file']}")
+                lines.append("```python")
+                lines.append(example["snippet"])
+                lines.append("```")
+        return "\n".join(lines)

body/self_healing/test_context/parsers.py

@@ -0,0 +1,70 @@
+# src/body/self_healing/test_context/parsers.py
+
+"""Refactored logic for src/features/self_healing/test_context/parsers.py."""
+
+from __future__ import annotations
+
+import ast
+from typing import Any
+
+
+# ID: 02c15180-d580-44dc-9e1a-1389d1bf16b1
+def extract_classes(tree: ast.AST) -> list[dict[str, Any]]:
+    classes = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            methods = [
+                {
+                    "name": i.name,
+                    "docstring": ast.get_docstring(i),
+                    "is_private": i.name.startswith("_"),
+                    "args": [a.arg for a in i.args.args],
+                }
+                for i in node.body
+                if isinstance(i, ast.FunctionDef)
+            ]
+            classes.append(
+                {
+                    "name": node.name,
+                    "docstring": ast.get_docstring(node),
+                    "methods": methods,
+                    "bases": [get_node_name(b) for b in node.bases],
+                }
+            )
+    return classes
+
+
+# ID: 74d8bef6-1e3a-4cf6-821a-afbb5f73c20b
+def extract_functions(tree: ast.AST) -> list[dict[str, Any]]:
+    return [
+        {
+            "name": n.name,
+            "docstring": ast.get_docstring(n),
+            "is_private": n.name.startswith("_"),
+            "is_async": isinstance(n, ast.AsyncFunctionDef),
+            "args": [a.arg for a in n.args.args],
+        }
+        for n in tree.body
+        if isinstance(n, ast.FunctionDef)
+    ]
+
+
+# ID: ca485404-dd90-40b7-ad92-6ecf6662d455
+def extract_imports(tree: ast.AST) -> list[str]:
+    imports = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.add(alias.name)
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            imports.add(node.module)
+    return list(imports)
+
+
+# ID: 265374a7-bcf7-44fc-b776-e89909c89f10
+def get_node_name(node: ast.AST) -> str:
+    if isinstance(node, ast.Name):
+        return node.id
+    if isinstance(node, ast.Attribute):
+        return f"{get_node_name(node.value)}.{node.attr}"
+    return str(node)

body/self_healing/test_context_analyzer.py

@@ -0,0 +1,79 @@
+# src/body/self_healing/test_context_analyzer.py
+
+"""
+Analyzes target modules to build rich context for test generation.
+Refactored for High Fidelity (V2.3).
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+# REFACTORED: Removed direct settings import
+from shared.logger import getLogger
+
+from .test_context import detectors, examples, metrics, parsers
+from .test_context.models import ModuleContext
+
+
+logger = getLogger(__name__)
+
+
+# ID: d3ee69df-00b1-4ac4-bfb9-9f559007e7db
+class TestContextAnalyzer:
+    """Analyzes modules to gather rich context for test generation."""
+
+    __test__ = False
+
+    def __init__(self, repo_root: Path) -> None:
+        self.repo_root = repo_root
+
+    # ID: 195772da-8fff-4360-a6f8-362d5e1156e5
+    async def analyze_module(self, module_path: str) -> ModuleContext:
+        logger.info("Analyzing module: %s", module_path)
+        full_path = self.repo_root / module_path
+        if not full_path.exists():
+            raise FileNotFoundError(f"Module not found: {full_path}")
+
+        source_code = full_path.read_text(encoding="utf-8")
+        try:
+            tree = ast.parse(source_code)
+        except SyntaxError as e:
+            logger.error("Failed to parse %s: %s", module_path, e)
+            raise
+
+        cls_list = parsers.extract_classes(tree)
+        fn_list = parsers.extract_functions(tree)
+        imp_list = parsers.extract_imports(tree)
+
+        cov_info = metrics.get_coverage_data(self.repo_root, module_path)
+        sim_tests = examples.find_similar_tests(
+            self.repo_root, full_path.stem, cls_list, fn_list
+        )
+
+        return ModuleContext(
+            module_path=module_path,
+            module_name=full_path.stem,
+            import_path=module_path.replace("src/", "")
+            .replace(".py", "")
+            .replace("/", "."),
+            source_code=source_code,
+            module_docstring=ast.get_docstring(tree),
+            classes=cls_list,
+            functions=fn_list,
+            imports=imp_list,
+            dependencies=detectors.analyze_dependencies(imp_list),
+            current_coverage=cov_info["coverage"],
+            uncovered_lines=cov_info["uncovered_lines"],
+            uncovered_functions=cov_info["uncovered_functions"],
+            similar_test_files=sim_tests,
+            external_deps=detectors.identify_external_deps(imp_list),
+            filesystem_usage=detectors.detect_fs_usage(source_code),
+            database_usage=detectors.detect_db_usage(source_code),
+            network_usage=detectors.detect_network_usage(source_code),
+        )
+
+
+# Ensure the type is exported for external modules
+__all__ = ["ModuleContext", "TestContextAnalyzer"]

body/self_healing/test_failure_analyzer.py

@@ -0,0 +1,259 @@
+# src/body/self_healing/test_failure_analyzer.py
+
+"""Analyzes pytest test failures to provide actionable context for fixing tests.
+
+This service parses pytest output to understand what went wrong, extracting:
+- Which tests failed
+- Expected vs actual values
+- Assertion details
+- Error messages
+
+This context is then used to guide test fixing iterations.
+"""
+
+from __future__ import annotations
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+import logging
+import re
+from dataclasses import dataclass
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+# ID: ce68287c-ce0d-4930-8b6d-e0b1ad881c7a
+class TestFailure:
+    """Represents a single test failure with context."""
+
+    __test__ = False
+
+    test_name: str
+    test_class: str | None
+    failure_type: str
+    expected: str | None
+    actual: str | None
+    assertion: str
+    error_message: str
+    full_context: str
+
+    # ID: 9f359f13-f4f4-4529-8094-da05742defe9
+    def to_fix_context(self) -> str:
+        """Convert to human-readable context for LLM."""
+        lines = []
+        if self.test_class:
+            lines.append(f"Test: {self.test_class}::{self.test_name}")
+        else:
+            lines.append(f"Test: {self.test_name}")
+        lines.append(f"Failure: {self.failure_type}")
+        if self.expected and self.actual:
+            lines.append(f"Expected: {self.expected}")
+            lines.append(f"Got: {self.actual}")
+        if self.assertion:
+            lines.append(f"Assertion: {self.assertion}")
+        if self.error_message:
+            lines.append(f"Error: {self.error_message}")
+        return "\n".join(lines)
+
+
+@dataclass
+# ID: e036107b-4c4e-413e-a8d6-179104bb0515
+class TestResults:
+    """Summary of test execution results."""
+
+    total: int
+    passed: int
+    failed: int
+    failures: list[TestFailure]
+    output: str
+
+    @property
+    # ID: 3089cc43-f575-4d39-838e-173e6ea33f98
+    def success_rate(self) -> float:
+        """Calculate success rate as percentage."""
+        if self.total == 0:
+            return 0.0
+        return self.passed / self.total * 100
+
+
+# ID: 4f440d3f-fede-47ce-b13f-21d1fb93fb8b
+class TestFailureAnalyzer:
+    """
+    Analyzes pytest output to extract actionable failure information.
+
+    This parser handles pytest's verbose output format and extracts
+    structured information about what went wrong.
+    """
+
+    __test__ = False
+
+    def __init__(self):
+        """Initialize the analyzer."""
+        pass  # ← Add this
+
+    # ID: b671d25d-006b-4403-a493-eb19575540d3
+    def analyze(self, pytest_output: str, pytest_errors: str = "") -> TestResults:
+        """
+        Parse pytest output and extract failure information.
+
+        Args:
+            pytest_output: stdout from pytest
+            pytest_errors: stderr from pytest
+
+        Returns:
+            TestResults with structured failure information
+        """
+        combined_output = pytest_output + "\n" + pytest_errors
+        summary = self._extract_summary(combined_output)
+        failures = self._extract_failures(combined_output)
+        return TestResults(
+            total=summary["total"],
+            passed=summary["passed"],
+            failed=summary["failed"],
+            failures=failures,
+            output=combined_output,
+        )
+
+    def _extract_summary(self, output: str) -> dict[str, int]:
+        """Extract test count summary from pytest output."""
+        summary_pattern = r"(\d+)\s+failed.*?(\d+)\s+passed"
+        match = re.search(summary_pattern, output)
+        if match:
+            failed = int(match.group(1))
+            passed = int(match.group(2))
+            return {"total": failed + passed, "passed": passed, "failed": failed}
+        passed_pattern = r"(\d+)\s+passed"
+        match = re.search(passed_pattern, output)
+        if match:
+            passed = int(match.group(1))
+            return {"total": passed, "passed": passed, "failed": 0}
+        return {"total": 0, "passed": 0, "failed": 0}
+
+    def _extract_failures(self, output: str) -> list[TestFailure]:
+        """Extract detailed failure information from pytest output."""
+        failures = []
+        failure_lines = self._find_failure_lines(output)
+        for line in failure_lines:
+            failure = self._parse_failure_line(line, output)
+            if failure:
+                failures.append(failure)
+        return failures
+
+    def _find_failure_lines(self, output: str) -> list[str]:
+        """Find all FAILED lines in pytest output."""
+        lines = []
+        for line in output.split("\n"):
+            if line.startswith("FAILED "):
+                lines.append(line)
+        return lines
+
+    def _parse_failure_line(
+        self, failure_line: str, full_output: str
+    ) -> TestFailure | None:
+        """
+        Parse a single FAILED line and extract context.
+
+        Example line:
+        FAILED tests/shared/test_header_tools.py::TestHeaderTools::test_parse_empty - AssertionError: assert [] == ['']
+        """
+        try:
+            parts = failure_line.split(" - ", 1)
+            if len(parts) < 2:
+                return None
+            test_path = parts[0].replace("FAILED ", "")
+            error_part = parts[1]
+            path_parts = test_path.split("::")
+            if len(path_parts) == 3:
+                test_class = path_parts[1]
+                test_name = path_parts[2]
+            elif len(path_parts) == 2:
+                test_class = None
+                test_name = path_parts[1]
+            else:
+                return None
+            failure_type = error_part.split(":")[0].strip()
+            expected, actual = self._extract_assertion_values(error_part)
+            assertion = self._extract_assertion(error_part)
+            context = self._find_failure_context(test_name, full_output)
+            return TestFailure(
+                test_name=test_name,
+                test_class=test_class,
+                failure_type=failure_type,
+                expected=expected,
+                actual=actual,
+                assertion=assertion,
+                error_message=error_part,
+                full_context=context,
+            )
+        except Exception as e:
+            logger.warning("Failed to parse failure line: {failure_line}: %s", e)
+            return None
+
+    def _extract_assertion_values(
+        self, error_text: str
+    ) -> tuple[str | None, str | None]:
+        """Extract expected and actual values from assertion error."""
+        assert_pattern = r"assert (.+?) == (.+?)(?:\n|$|\s+\+)"
+        match = re.search(assert_pattern, error_text)
+        if match:
+            actual = match.group(1).strip()
+            expected = match.group(2).strip()
+            return (expected, actual)
+        expected_pattern = r"[Ee]xpected:?\s*(.+?)(?:\n|$)"
+        actual_pattern = r"[Gg]ot:?\s*(.+?)(?:\n|$)"
+        expected_match = re.search(expected_pattern, error_text)
+        actual_match = re.search(actual_pattern, error_text)
+        expected = expected_match.group(1).strip() if expected_match else None
+        actual = actual_match.group(1).strip() if actual_match else None
+        return (expected, actual)
+
+    def _extract_assertion(self, error_text: str) -> str:
+        """Extract the actual assertion statement."""
+        assert_pattern = r"(assert .+?)(?:\n|\s+\+|$)"
+        match = re.search(assert_pattern, error_text)
+        if match:
+            return match.group(1).strip()
+        return error_text.split("\n")[0] if error_text else ""
+
+    def _find_failure_context(self, test_name: str, full_output: str) -> str:
+        """Find additional context about the failure in full output."""
+        lines = full_output.split("\n")
+        context_lines = []
+        capturing = False
+        for line in lines:
+            if test_name in line:
+                capturing = True
+            if capturing:
+                context_lines.append(line)
+                if line.startswith("FAILED ") and test_name not in line:
+                    break
+                if line.startswith("===") and len(context_lines) > 5:
+                    break
+        return "\n".join(context_lines[:30])
+
+    # ID: 88fe19e7-0abc-4abd-a435-1636caa2a229
+    def generate_fix_summary(self, results: TestResults) -> str:
+        """
+        Generate a human-readable summary for the LLM to understand failures.
+
+        This is what gets added to the fix prompt.
+        """
+        if results.failed == 0:
+            return "✅ All tests passed!"
+        lines = [
+            f"Test Results: {results.passed}/{results.total} passed ({results.success_rate:.1f}%)",
+            f"Failures: {results.failed}",
+            "",
+            "Detailed Failures:",
+            "",
+        ]
+        for i, failure in enumerate(results.failures, 1):
+            lines.append(f"FAILURE {i}:")
+            lines.append(failure.to_fix_context())
+            lines.append("")
+        return "\n".join(lines)