core-runtime 0.1.1__py3-none-any.whl

will/self_healing/test_generation/automatic_repair.py

@@ -0,0 +1,377 @@
+# src/will/self_healing/test_generation/automatic_repair.py
+
+"""
+Automatic code repair using specialized micro-fixers.
+
+Philosophy: Each fixer does ONE thing perfectly. Chain them together.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: e69950b7-11bd-4c88-b1f3-04f24b03fe21
+class QuoteFixer:
+    """Fixes mismatched triple quotes - ONE PROBLEM ONLY."""
+
+    @staticmethod
+    # ID: 377b67e7-5c64-41c5-a3d7-f1794b0cf934
+    def fix(code: str) -> tuple[str, bool]:
+        """
+        Fix lines with mismatched triple quotes.
+
+        Pattern: Triple-quoted strings with 4+ quotes at end become 3 quotes.
+
+        Returns: (fixed_code, was_changed)
+        """
+        if not code:
+            return (code, False)
+        lines = code.split("\n")
+        fixed_lines = []
+        changed = False
+        for line in lines:
+            original = line
+            if re.search('"{4,}\\s*$', line):
+                line = re.sub('"{4,}\\s*$', '"""', line)
+                changed = True
+            if re.search("'{4,}\\s*$", line):
+                line = re.sub("'{4,}\\s*$", "'''", line)
+                changed = True
+            fixed_lines.append(line)
+        if changed:
+            logger.info("QuoteFixer: Fixed mismatched triple quotes")
+        return ("\n".join(fixed_lines), changed)
+
+
+# ID: 2fb2a6e6-beb3-4b8d-8693-548b89617804
+class UnterminatedStringFixer:
+    """Closes unterminated multiline strings - ONE PROBLEM ONLY."""
+
+    @staticmethod
+    # ID: 11670780-5071-4b27-859d-a7a4ef15dbfa
+    def fix(code: str) -> tuple[str, bool]:
+        """
+        Close unterminated triple-quoted strings.
+
+        Returns: (fixed_code, was_changed)
+        """
+        if not code:
+            return (code, False)
+        double_count = code.count('"""')
+        single_count = code.count("'''")
+        changed = False
+        if double_count % 2 == 1:
+            code = code + '\n"""'
+            changed = True
+            logger.info("UnterminatedStringFixer: Closed unterminated ''' string")
+        if single_count % 2 == 1:
+            code = code + "\n'''"
+            changed = True
+            logger.info('UnterminatedStringFixer: Closed unterminated """ string')
+        return (code, changed)
+
+
+# ID: 4faa130f-26c4-41da-8199-5b264dbd70f8
+class TrailingWhitespaceFixer:
+    """Removes trailing whitespace - ONE PROBLEM ONLY."""
+
+    @staticmethod
+    # ID: 4fb77c31-1302-4a9d-8ecc-0a0d47a0ce5b
+    def fix(code: str) -> tuple[str, bool]:
+        """
+        Remove trailing whitespace from lines.
+
+        Returns: (fixed_code, was_changed)
+        """
+        if not code:
+            return (code, False)
+        lines = code.split("\n")
+        fixed_lines = [line.rstrip() for line in lines]
+        changed = "\n".join(lines) != "\n".join(fixed_lines)
+        if changed:
+            logger.info("TrailingWhitespaceFixer: Removed trailing whitespace")
+        return ("\n".join(fixed_lines), changed)
+
+
+# ID: 81309469-3551-422c-8409-79a2e45b7805
+class EmptyFunctionFixer:
+    """Fixes functions and classes with no body - ONE PROBLEM ONLY."""
+
+    @staticmethod
+    # ID: 1b0d042a-b4af-44b6-a1ba-76444a6e6b76
+    def fix(code: str) -> tuple[str, bool]:
+        """
+        Fix functions/classes that have no body (causes "expected an indented block" error).
+
+        Adds a pass statement to empty functions and classes.
+
+        Returns: (fixed_code, was_changed)
+        """
+        if not code:
+            return (code, False)
+        lines = code.split("\n")
+        fixed_lines = []
+        changed = False
+        for i, line in enumerate(lines):
+            fixed_lines.append(line)
+            stripped = line.strip()
+            is_def = stripped.startswith("def ") and stripped.endswith(":")
+            is_class = stripped.startswith("class ") and stripped.endswith(":")
+            if is_def or is_class:
+                if i + 1 < len(lines):
+                    next_line = lines[i + 1]
+                    next_stripped = next_line.strip()
+                    if not next_stripped or (
+                        next_stripped and (not next_line.startswith((" ", "\t")))
+                    ):
+                        fixed_lines.append("    pass")
+                        changed = True
+                        kind = "class" if is_class else "function"
+                        logger.info(
+                            "EmptyFunctionFixer: Added 'pass' to empty %s on line %s",
+                            kind,
+                            i + 1,
+                        )
+                elif i + 1 == len(lines):
+                    fixed_lines.append("    pass")
+                    changed = True
+                    kind = "class" if is_class else "function"
+                    logger.info(
+                        "EmptyFunctionFixer: Added 'pass' to empty %s at EOF", kind
+                    )
+        return ("\n".join(fixed_lines), changed)
+
+
+# ID: 6548afb9-f4b5-468e-90b2-c42f1ac9fddf
+class MixedQuoteFixer:
+    """Fixes mixed quote usage where triple quotes are used incorrectly - ONE PROBLEM ONLY."""
+
+    @staticmethod
+    # ID: fdc484f9-afa9-4989-a92c-37ff425257c2
+    def fix(code: str) -> tuple[str, bool]:
+        """
+        Fix cases where triple quotes are used in non-docstring contexts.
+
+        Replaces triple quotes with single quotes when they appear in
+        function calls or other non-docstring contexts.
+
+        Returns: (fixed_code, was_changed)
+        """
+        if not code:
+            return (code, False)
+        lines = code.split("\n")
+        fixed_lines = []
+        changed = False
+        for line in lines:
+            original = line
+            stripped = line.strip()
+            is_likely_docstring = (
+                (
+                    stripped.startswith('"""')
+                    and stripped.endswith('"""')
+                    and (len(stripped) > 6)
+                )
+                or (
+                    stripped.startswith("'''")
+                    and stripped.endswith("'''")
+                    and (len(stripped) > 6)
+                )
+                or ("def " in line or "class " in line)
+            )
+            if not is_likely_docstring:
+                if '"""' in line and line.count('"""') == 1:
+                    line = line.replace('"""', '"')
+                    changed = True
+                if "'''" in line and line.count("'''") == 1:
+                    line = line.replace("'''", "'")
+                    changed = True
+            if line != original:
+                logger.info(
+                    "MixedQuoteFixer: Fixed mixed quotes in non-docstring context"
+                )
+            fixed_lines.append(line)
+        return ("\n".join(fixed_lines), changed)
+
+
+# ID: 1e3e976c-a02d-476a-ab8a-86ed80d30199
+class TruncatedDocstringFixer:
+    """Fixes truncated/incomplete docstrings - ONE PROBLEM ONLY."""
+
+    @staticmethod
+    # ID: f5c8c78f-4079-45b2-afbb-ef374dcda022
+    def fix(code: str) -> tuple[str, bool]:
+        """
+        Fix docstrings and raw strings that start but don't close properly.
+
+        Handles both single-line and multi-line cases.
+
+        Returns: (fixed_code, was_changed)
+        """
+        if not code:
+            return (code, False)
+        lines = code.split("\n")
+        fixed_lines = []
+        changed = False
+        in_multiline = False
+        multiline_quote = None
+        for i, line in enumerate(lines):
+            if not in_multiline:
+                if '"""' in line:
+                    count = line.count('"""')
+                    if count % 2 == 1:
+                        in_multiline = True
+                        multiline_quote = '"""'
+                elif "'''" in line:
+                    count = line.count("'''")
+                    if count % 2 == 1:
+                        in_multiline = True
+                        multiline_quote = "'''"
+                stripped = line.strip()
+                if not in_multiline:
+                    if (
+                        stripped.startswith('"""')
+                        and (not stripped.endswith('"""'))
+                        and (stripped.count('"""') == 1)
+                    ):
+                        line = line + '"""'
+                        changed = True
+                        logger.info(
+                            "TruncatedDocstringFixer: Closed single-line docstring on line %s",
+                            i + 1,
+                        )
+                    elif (
+                        stripped.startswith("'''")
+                        and (not stripped.endswith("'''"))
+                        and (stripped.count("'''") == 1)
+                    ):
+                        line = line + "'''"
+                        changed = True
+                        logger.info(
+                            "TruncatedDocstringFixer: Closed single-line docstring on line %s",
+                            i + 1,
+                        )
+            else:
+                if multiline_quote in line:
+                    in_multiline = False
+                    multiline_quote = None
+                stripped = line.rstrip()
+                if (
+                    stripped.endswith('"')
+                    and (not stripped.endswith('"""'))
+                    and (multiline_quote == '"""')
+                ):
+                    line = line.rstrip('"') + '"""'
+                    changed = True
+                    in_multiline = False
+                    multiline_quote = None
+                    logger.info(
+                        "TruncatedDocstringFixer: Fixed wrong closing quote on line %s",
+                        i + 1,
+                    )
+                elif (
+                    stripped.endswith("'")
+                    and (not stripped.endswith("'''"))
+                    and (multiline_quote == "'''")
+                ):
+                    line = line.rstrip("'") + "'''"
+                    changed = True
+                    in_multiline = False
+                    multiline_quote = None
+                    logger.info(
+                        "TruncatedDocstringFixer: Fixed wrong closing quote on line %s",
+                        i + 1,
+                    )
+            fixed_lines.append(line)
+        if in_multiline and multiline_quote:
+            fixed_lines.append(multiline_quote)
+            changed = True
+            logger.info("TruncatedDocstringFixer: Added missing closing quotes at EOF")
+        return ("\n".join(fixed_lines), changed)
+
+
+# ID: ebd6246c-8ffb-4d30-a5c4-732638a809e6
+class EOFSyntaxFixer:
+    """Fixes EOF syntax errors - ONE PROBLEM ONLY."""
+
+    @staticmethod
+    # ID: 56c8eef1-3ace-483b-bf7f-47a5d5621e55
+    def fix(code: str) -> tuple[str, bool]:
+        """
+        Fix EOF errors by attempting to close unclosed structures.
+
+        Returns: (fixed_code, was_changed)
+        """
+        if not code:
+            return (code, False)
+        try:
+            ast.parse(code)
+            return (code, False)
+        except SyntaxError as e:
+            error_msg = str(e)
+            if "EOF while scanning triple-quoted string" in error_msg:
+                if code.count('"""') % 2 == 1:
+                    logger.info('EOFSyntaxFixer: Closing unclosed """ string')
+                    return (code + '\n"""', True)
+                if code.count("'''") % 2 == 1:
+                    logger.info("EOFSyntaxFixer: Closing unclosed ''' string")
+                    return (code + "\n'''", True)
+        return (code, False)
+
+
+# ID: 09e40640-e672-4ccb-bb0c-0391e2b6121b
+class AutomaticRepairService:
+    """
+    Orchestrates micro-fixers in a pipeline.
+
+    Strategy: Run each fixer in sequence, up to N iterations.
+    Stop when nothing changes or code becomes valid.
+    """
+
+    def __init__(self):
+        self.fixers = [
+            EmptyFunctionFixer(),
+            MixedQuoteFixer(),
+            TruncatedDocstringFixer(),
+            QuoteFixer(),
+            UnterminatedStringFixer(),
+            EOFSyntaxFixer(),
+            TrailingWhitespaceFixer(),
+        ]
+        self.max_iterations = 3
+
+    # ID: 638d7b88-7280-4ee6-881a-3909a9caf556
+    def apply_all_repairs(self, code: str) -> tuple[str, list[str]]:
+        """
+        Apply all fixers iteratively until nothing changes.
+
+        Returns:
+            (repaired_code, list_of_repairs_applied)
+        """
+        repairs_applied = []
+        current_code = code
+        for iteration in range(self.max_iterations):
+            any_changed = False
+            for fixer in self.fixers:
+                fixed_code, changed = fixer.fix(current_code)
+                if changed:
+                    any_changed = True
+                    fixer_name = fixer.__class__.__name__
+                    repair_key = f"{fixer_name}_iter{iteration}"
+                    repairs_applied.append(repair_key)
+                    current_code = fixed_code
+            if not any_changed:
+                break
+            try:
+                ast.parse(current_code)
+                logger.info("Code became valid after %s iteration(s)", iteration + 1)
+                break
+            except SyntaxError:
+                continue
+        return (current_code, repairs_applied)

will/self_healing/test_generation/code_extractor.py

@@ -0,0 +1,238 @@
+# src/will/self_healing/test_generation/code_extractor.py
+"""
+Robust Python code extraction for test generation.
+
+Centralizes the logic for turning messy LLM responses into a clean
+Python snippet that Black and the validator can handle.
+
+Behaviors:
+- Prefer JSON/markdown-aware extraction via shared.utils.parsing
+- Fallback to a best-effort "strip fences + find first code line"
+- Normalize common glitches like leading literal '\\n' or stray backslashes
+- Repair invalid multi-line string syntax often generated by LLMs
+- Strip XML artifact tags (<final_code>) if they leak through
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+
+from shared.logger import getLogger
+from shared.utils.parsing import extract_python_code_from_response
+
+
+logger = getLogger(__name__)
+
+
+# ID: ae84e8f9-4d59-4827-b46b-2e4b4a54ca8d
+class CodeExtractor:
+    """Extracts and lightly normalizes Python code from LLM responses."""
+
+    # ID: 6f94fcb3-7b9f-46f2-8f75-0b45c9649c3b
+    def extract(self, response: str) -> str | None:
+        """
+        Main entrypoint: extract a usable Python snippet.
+
+        Strategy:
+        1. Check for explicit <final_code> XML tags.
+        2. Use shared parsing utils to find fenced blocks.
+        3. Fallback to raw text analysis.
+        4. Repair syntax errors and strip artifact tags.
+        """
+        if not response:
+            return None
+
+        # 1. XML Encapsulation Strategy
+        xml_code = self._extract_xml_tagged_code(response)
+        if xml_code:
+            return self._post_process(xml_code)
+
+        # 2. First try the shared extractor (fenced blocks)
+        primary = extract_python_code_from_response(response)
+        if primary:
+            return self._post_process(primary)
+
+        # 3. Fallback: strip markdown and find first code line
+        fallback = self._fallback_extract_python(response)
+        if fallback:
+            return self._post_process(fallback)
+
+        logger.warning(
+            "CodeExtractor: no Python code could be extracted from response preview: %r",
+            response[:200],
+        )
+        return None
+
+    def _extract_xml_tagged_code(self, text: str) -> str | None:
+        """
+        Extracts content within <final_code> tags.
+        """
+        pattern = r"<final_code[^>]*>(.*?)</final_code>"
+        match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
+        if match:
+            content = match.group(1).strip()
+            # If the LLM put fences INSIDE the tags, strip them too
+            if "```" in content:
+                return extract_python_code_from_response(content)
+            return content
+        return None
+
+    def _fallback_extract_python(self, text: str) -> str | None:
+        """
+        Best-effort extraction for messy responses that defeat the primary extractor.
+        """
+        if not text:
+            return None
+
+        # Remove obvious fenced code markers
+        cleaned = text.replace("```python", "").replace("```py", "").replace("```", "")
+
+        lines = [ln.rstrip("\r\n") for ln in cleaned.splitlines()]
+
+        code_start = 0
+        for idx, line in enumerate(lines):
+            stripped = line.lstrip()
+            if not stripped:
+                continue
+            if stripped.startswith(
+                (
+                    "def ",
+                    "async def ",
+                    "class ",
+                    "import ",
+                    "from ",
+                    "#",
+                    "@",
+                )
+            ):
+                code_start = idx
+                break
+
+        code_lines = lines[code_start:]
+        if not any(ln.strip() for ln in code_lines):
+            return None
+
+        return "\n".join(code_lines).strip()
+
+    def _post_process(self, code: str) -> str:
+        """
+        Light normalization of the extracted snippet.
+        """
+        if not code:
+            return code
+
+        # 1) Strip XML tags if they leaked through
+        code = re.sub(r"</?final_code[^>]*>", "", code, flags=re.IGNORECASE)
+
+        # 2) Turn escaped newlines into real newlines
+        if "\\n" in code:
+            code = code.replace("\\n", "\n")
+
+        lines = code.splitlines()
+        if not lines:
+            return code
+
+        # 3) Drop leading completely empty / whitespace-only lines
+        while lines and not lines[0].strip():
+            lines.pop(0)
+
+        if not lines:
+            return ""
+
+        # 4) Fix first line glitches
+        first = lines[0]
+        if first.startswith("\\n"):
+            first = first[2:]
+        if first.startswith("\\") and not first.startswith("\\\\"):
+            first = first.lstrip("\\")
+        lines[0] = first
+
+        # 5) Strip stray leading backslashes
+        fixed_lines: list[str] = []
+        for line in lines:
+            if line.startswith("\\") and not line.startswith("\\\\"):
+                fixed_lines.append(line.lstrip("\\"))
+            else:
+                fixed_lines.append(line)
+
+        # 6) Re-join
+        normalized = "\n".join(fixed_lines).rstrip() + "\n"
+
+        # 7) Fix syntax errors where single quotes span multiple lines
+        normalized = self._repair_multiline_strings(normalized)
+
+        return normalized
+
+    def _repair_multiline_strings(self, code: str) -> str:
+        """
+        Detects and fixes invalid multi-line strings created with single/double quotes.
+        Matches assignments, assertions, returns, and function calls.
+        """
+        try:
+            ast.parse(code)
+            return code
+        except SyntaxError:
+            pass
+
+        lines = code.splitlines()
+        new_lines = []
+
+        in_broken_string = False
+        quote_char = None
+
+        # Regex: (prefix_context)(string_prefix)(quote)(content)
+        # Prefix context matches:
+        # - Assignments: var =
+        # - Keywords: assert, return, yield, raise
+        # - Function calls: func(
+        # - Operators: ==, !=, in
+        start_pattern = re.compile(
+            r'^(\s*(?:[\w_.]+\s*=|assert\s+|return\s+|yield\s+|raise\s+|.*?\(\s*|.*?\s+(?:==|!=|in)\s+))([frbuFRBU]*)(["\'])(.*)$'
+        )
+
+        for line in lines:
+            if in_broken_string:
+                stripped = line.rstrip()
+                if stripped.endswith(quote_char) and not stripped.endswith(
+                    f"\\{quote_char}"
+                ):
+                    if stripped == quote_char:
+                        fixed_line = line.replace(quote_char, quote_char * 3, 1)
+                    else:
+                        fixed_line = line.rstrip()[:-1] + (quote_char * 3)
+                    new_lines.append(fixed_line)
+                    in_broken_string = False
+                    quote_char = None
+                else:
+                    new_lines.append(line)
+                continue
+
+            match = start_pattern.match(line)
+            if match:
+                prefix_part = match.group(1)
+                string_prefix = match.group(2)
+                q = match.group(3)
+                content = match.group(4)
+
+                # Check if it's actually a valid single line string
+                if content.strip().endswith(q) and not content.strip().endswith(
+                    f"\\{q}"
+                ):
+                    new_lines.append(line)
+                    continue
+
+                # Check if it's already triple quoted
+                if content.startswith(q * 2):
+                    new_lines.append(line)
+                    continue
+
+                # It looks like a broken multi-line start; convert to triple quotes
+                new_line = f"{prefix_part}{string_prefix}{q * 3}{content}"
+                new_lines.append(new_line)
+                in_broken_string = True
+                quote_char = q
+            else:
+                new_lines.append(line)
+
+        return "\n".join(new_lines) + "\n"