core-runtime 0.1.1__py3-none-any.whl

will/self_healing/context_aware_test_generator.py

@@ -0,0 +1,298 @@
+# src/will/self_healing/context_aware_test_generator.py
+
+"""Context-aware test generator using ContextPackage for better results.
+
+This improves on SimpleTestGenerator by providing the LLM with richer context.
+Enforces non-blocking I/O to satisfy the Async-Native architectural contract.
+Complies with Body Contracts by avoiding direct os.environ access.
+"""
+
+from __future__ import annotations
+
+import ast
+import asyncio
+import datetime
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from body.services.file_service import FileService
+from body.services.service_registry import service_registry
+from shared.ai.prompt_model import PromptModel
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+from shared.utils.parsing import extract_python_code_from_response
+from will.orchestration.cognitive_service import CognitiveService
+
+
+logger = getLogger(__name__)
+
+_CFG = load_operational_config().testing
+
+
+# ID: 87134386-7269-4628-a6fb-952bf6f2790e
+class ContextAwareTestGenerator:
+    """Generates tests using ContextPackage for richer context."""
+
+    def __init__(
+        self,
+        cognitive_service: CognitiveService,
+        file_handler: FileService,
+        repo_root: Path,
+    ) -> None:
+        """Initialize with LLM service and governed file operations."""
+        self.cognitive = cognitive_service
+        self.file_handler = file_handler
+        self.repo_root = repo_root
+
+    # ID: 4a5a573a-9c74-4048-adfb-0affde2d6aaa
+    async def generate_test_for_symbol(
+        self, file_path: str, symbol_name: str
+    ) -> dict[str, Any]:
+        """Generate a test for ONE symbol with full context."""
+        try:
+            from shared.infrastructure.context.service import ContextService
+
+            context_service = ContextService(
+                cognitive_service=self.cognitive,
+                project_root=str(self.repo_root),
+                session_factory=service_registry.session,
+                brain_services_provider=service_registry,
+            )
+
+            symbol_code = await asyncio.to_thread(
+                self._extract_symbol_code, file_path, symbol_name
+            )
+            if not symbol_code:
+                return {
+                    "status": "skipped",
+                    "test_code": None,
+                    "passed": False,
+                    "reason": f"Could not extract {symbol_name} from {file_path}",
+                }
+
+            context_packet = await context_service.build_for_task(
+                {
+                    "task_id": f"test_gen_{symbol_name}",
+                    "task_type": "test.generate",
+                    "summary": f"Generate test for {symbol_name} in {file_path}",
+                    "target_file": file_path,
+                    "target_symbol": symbol_name,
+                    "scope": {"traversal_depth": 1},
+                },
+                use_cache=True,
+            )
+
+            test_code = await self._generate_test_with_context(
+                file_path=file_path,
+                symbol_name=symbol_name,
+                symbol_code=symbol_code,
+                context_packet=context_packet,
+            )
+
+            if not test_code:
+                return {
+                    "status": "failed",
+                    "test_code": None,
+                    "passed": False,
+                    "reason": "LLM did not return valid code",
+                }
+
+            passed, error = await self._try_run_test(test_code, symbol_name, file_path)
+
+            if passed:
+                return {
+                    "status": "success",
+                    "test_code": test_code,
+                    "passed": True,
+                    "reason": "Test compiled and passed",
+                }
+
+            return {
+                "status": "failed",
+                "test_code": test_code,
+                "passed": False,
+                "reason": f"Test failed: {error}",
+            }
+
+        except Exception as exc:
+            logger.error("Error generating test for %s: %s", symbol_name, exc)
+            return {
+                "status": "failed",
+                "test_code": None,
+                "passed": False,
+                "reason": str(exc),
+            }
+
+    async def _generate_test_with_context(
+        self,
+        file_path: str,
+        symbol_name: str,
+        symbol_code: str,
+        context_packet: dict[str, Any],
+    ) -> str | None:
+        """Generate test code using ContextPackage information."""
+        module_path = (
+            file_path.replace("src/", "", 1).replace(".py", "").replace("/", ".")
+        )
+
+        try:
+            model = PromptModel.load("context_aware_test_gen")
+            client = await self.cognitive.aget_client_for_role(model.manifest.role)
+            response = await model.invoke(
+                context={
+                    "file_path": file_path,
+                    "symbol_name": symbol_name,
+                    "symbol_code": symbol_code,
+                    "module_path": module_path,
+                },
+                client=client,
+                user_id="ctx_test_gen",
+            )
+            return extract_python_code_from_response(response)
+        except Exception as exc:
+            logger.error("LLM request failed: %s", exc)
+            return None
+
+    def _extract_symbol_code(self, file_path: str, symbol_name: str) -> str | None:
+        """Extract source code for a specific symbol using AST."""
+        try:
+            full_path = self.repo_root / file_path
+            source = full_path.read_text(encoding="utf-8")
+            lines = source.splitlines()
+
+            tree = ast.parse(source)
+            for node in ast.walk(tree):
+                if (
+                    isinstance(
+                        node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+                    )
+                    and node.name == symbol_name
+                ):
+                    start = node.lineno - 1
+                    end = (
+                        node.end_lineno
+                        if hasattr(node, "end_lineno") and node.end_lineno
+                        else start + 10
+                    )
+                    return "\n".join(lines[start:end])
+
+            return None
+        except Exception as exc:
+            logger.debug("Failed to extract %s: %s", symbol_name, exc)
+            return None
+
+    async def _try_run_test(
+        self, test_code: str, symbol_name: str, source_file: str
+    ) -> tuple[bool, str]:
+        """Try to run the test without direct os.environ access."""
+        self.file_handler.ensure_dir("work/testing/failures")
+        self.file_handler.ensure_dir("work/testing/temp")
+
+        failures_dir = self.repo_root / "work" / "testing" / "failures"
+        temp_dir = self.repo_root / "work" / "testing" / "temp"
+
+        temp_path: str | None = None
+        content = (
+            f"# Auto-generated test for {symbol_name} from {source_file}\n"
+            "import pytest\n"
+            "from unittest.mock import MagicMock, AsyncMock, patch\n\n"
+            f"{test_code}\n"
+        )
+
+        try:
+
+            def _create_temp() -> str:
+                with tempfile.NamedTemporaryFile(
+                    mode="w",
+                    suffix=".py",
+                    delete=False,
+                    dir=temp_dir,
+                    encoding="utf-8",
+                ) as f:
+                    f.write(content)
+                    return f.name
+
+            temp_path = await asyncio.to_thread(_create_temp)
+            src_path = str((self.repo_root / "src").resolve())
+
+            proc = await asyncio.create_subprocess_exec(
+                "env",
+                f"PYTHONPATH={src_path}",
+                "poetry",
+                "run",
+                "pytest",
+                temp_path,
+                "-v",
+                "--tb=short",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=str(self.repo_root),
+            )
+
+            try:
+                stdout, stderr = await asyncio.wait_for(
+                    proc.communicate(), timeout=_CFG.context_aware_gen_timeout_sec
+                )
+            except TimeoutError:
+                proc.kill()
+                msg = f"Test timed out after {_CFG.context_aware_gen_timeout_sec:g} seconds"
+                await asyncio.to_thread(
+                    self._save_failed_test, symbol_name, content, msg
+                )
+                return False, msg
+
+            if proc.returncode == 0:
+                return True, ""
+
+            full_error = (
+                stderr.decode("utf-8", errors="replace")
+                + "\n"
+                + stdout.decode("utf-8", errors="replace")
+            )
+            await asyncio.to_thread(
+                self._save_failed_test, symbol_name, content, full_error
+            )
+            return False, full_error
+
+        except Exception as exc:
+            error_msg = str(exc)
+            if temp_path:
+                try:
+                    file_content = await asyncio.to_thread(
+                        Path(temp_path).read_text, encoding="utf-8"
+                    )
+                    await asyncio.to_thread(
+                        self._save_failed_test,
+                        symbol_name,
+                        file_content,
+                        error_msg,
+                    )
+                except Exception:
+                    await asyncio.to_thread(
+                        self._save_failed_test,
+                        symbol_name,
+                        content,
+                        error_msg,
+                    )
+            return False, error_msg
+        finally:
+            if temp_path:
+                await asyncio.to_thread(Path(temp_path).unlink, missing_ok=True)
+
+    def _save_failed_test(self, symbol_name: str, test_code: str, error: str) -> None:
+        """Sync helper for saving artifacts via governed channel."""
+        ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        test_file_rel = f"work/testing/failures/test_{symbol_name}_{ts}.py"
+        error_file_rel = f"work/testing/failures/test_{symbol_name}_{ts}.error.txt"
+
+        try:
+            result = self.file_handler.write_runtime_text(test_file_rel, test_code)
+            if result.status != "success":
+                raise RuntimeError(f"Governance rejected write: {result.message}")
+
+            result = self.file_handler.write_runtime_text(error_file_rel, error)
+            if result.status != "success":
+                raise RuntimeError(f"Governance rejected write: {result.message}")
+        except Exception as exc:
+            logger.warning("Failed to save artifacts: %s", exc)

will/self_healing/coverage_remediation_service.py

@@ -0,0 +1,97 @@
+# src/will/self_healing/coverage_remediation_service.py
+
+"""
+Enhanced coverage remediation service - V2 Adaptive Implementation.
+
+Following the V2 Alignment Roadmap, this service now routes all requests
+through the Enhanced/Adaptive generation path. The legacy monolithic
+V1 FullProjectRemediationService has been removed.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from body.services.file_service import FileService
+from mind.governance.audit_context import AuditorContext
+from shared.logger import getLogger
+from will.orchestration.cognitive_service import CognitiveService
+from will.self_healing.batch_remediation_service import (
+    BatchRemediationService,
+)  # Changed from body to will
+from will.self_healing.single_file_remediation import (
+    EnhancedSingleFileRemediationService,
+)  # Changed from body to will
+
+
+logger = getLogger(__name__)
+
+
+# ID: ce7c1db5-ef5b-4f70-9379-b5010b89e08d
+async def remediate_coverage_enhanced(
+    cognitive_service: CognitiveService,
+    auditor_context: AuditorContext,
+    file_handler: FileService,
+    repo_root: Path,
+    target_coverage: int | None = None,
+    file_path: Path | None = None,
+    max_complexity: str = "MODERATE",
+) -> dict[str, Any]:
+    """
+    Enhanced coverage remediation with rich context analysis.
+
+    If a specific file is provided, it uses surgical remediation.
+    Otherwise, it uses the BatchRemediationService to heal the project
+    prioritizing the lowest coverage areas.
+    """
+    if file_path:
+        logger.info("Starting V2 single-file remediation for: %s", file_path)
+        service = EnhancedSingleFileRemediationService(
+            cognitive_service=cognitive_service,
+            auditor_context=auditor_context,
+            file_path=file_path,
+            file_handler=file_handler,
+            repo_root=repo_root,
+            max_complexity=max_complexity,
+        )
+        return await service.remediate()
+
+    # V2 ALIGNMENT: Project-wide remediation now uses the Batch (prioritized) path
+    logger.info("Starting V2 batch remediation (Target: %s%%)", target_coverage or 75)
+    batch_service = BatchRemediationService(
+        cognitive_service=cognitive_service,
+        auditor_context=auditor_context,
+        max_complexity=max_complexity,
+    )
+
+    # We attempt to heal a batch of files (defaulting to 5 at a time for safety)
+    return await batch_service.process_batch(count=5)
+
+
+async def _remediate_coverage(
+    cognitive_service: CognitiveService,
+    auditor_context: AuditorContext,
+    file_handler: FileService,
+    repo_root: Path,
+    target_coverage: int | None = None,
+    file_path: Path | None = None,
+    max_complexity: str = "MODERATE",
+) -> dict[str, Any]:
+    """
+    Authoritative internal entry point for coverage remediation.
+    Maintained for background watchers (e.g. coverage_watcher.py).
+    """
+    return await remediate_coverage_enhanced(
+        cognitive_service=cognitive_service,
+        auditor_context=auditor_context,
+        file_handler=file_handler,
+        repo_root=repo_root,
+        target_coverage=target_coverage,
+        file_path=file_path,
+        max_complexity=max_complexity,
+    )
+
+
+# Alias for external consumers
+remediate_coverage = _remediate_coverage

will/self_healing/coverage_watcher.py

@@ -0,0 +1,192 @@
+# src/will/self_healing/coverage_watcher.py
+
+"""
+Constitutional coverage watcher.
+
+CONSTITUTIONAL FIX (V2.3):
+- Modularized to reduce Modularity Debt (51.2 -> ~41.0).
+- Uses V2.3 'CoverageMinimumCheck' from the Workflow Gate subsystem.
+- Encapsulates state management to remove I/O coupling from the main class.
+- Aligns with the Octopus-UNIX Synthesis.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+from mind.logic.engines.workflow_gate.checks.coverage import CoverageMinimumCheck
+from shared.infrastructure.config_service import ConfigService
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+from shared.path_resolver import PathResolver
+from will.self_healing.coverage_remediation_service import remediate_coverage
+
+
+logger = getLogger(__name__)
+
+_CFG = load_operational_config().coverage
+
+
+@dataclass(frozen=True)
+# ID: 10af153b-2b02-46ee-b06e-07afe2c5e69b
+class CoverageViolation:
+    """Represents a coverage violation detected by the Mind."""
+
+    timestamp: datetime
+    current_coverage: float
+    required_coverage: float
+    message: str
+
+
+# ID: 1f2e3d4c-5b6a-7890-abcd-ef1234567890
+class _WatcherState:
+    """Specialist for managing the persistent memory of the watcher."""
+
+    def __init__(self, repo_root: Any, state_path: str):
+        self.repo_root = repo_root
+        self.path = state_path
+
+    # ID: 5b86b122-7d5a-4cf5-ba5a-76c4d9bc2fb7
+    def get_last_remediation(self) -> datetime | None:
+        try:
+            abs_path = self.repo_root / self.path
+            if not abs_path.exists():
+                return None
+            data = json.loads(abs_path.read_text(encoding="utf-8"))
+            return datetime.fromisoformat(data.get("last_remediation", ""))
+        except Exception:
+            return None
+
+    # ID: 66ab3cb4-e3fe-424a-b908-e37273836d55
+    def record_success(self, violation: CoverageViolation):
+        from body.services.file_service import FileService
+
+        fh = FileService(str(self.repo_root))
+        state = {
+            "last_check": datetime.now().isoformat(),
+            "last_remediation": datetime.now().isoformat(),
+            "status": "remediated",
+            "last_violation": {
+                "current": violation.current_coverage,
+                "required": violation.required_coverage,
+            },
+        }
+        fh.write_runtime_json(self.path, state)
+
+
+# ID: c75a7281-9bb9-4c03-8dcf-2eb38c36f9a8
+class CoverageWatcher:
+    """
+    Monitors test coverage and triggers autonomous remediation.
+
+    Refactored for V2.3 to use the Workflow Gate engine and delegate state.
+    """
+
+    def __init__(self, config_service: ConfigService | None = None):
+        self.config_service = config_service
+        self._paths: PathResolver | None = None
+        self.gate_check: CoverageMinimumCheck | None = None
+        self.state: _WatcherState | None = None
+
+    async def _ensure_initialized(self, context: Any | None = None) -> None:
+        """Initialize path-dependent services once."""
+        if self._paths is not None and self.gate_check is not None and self.state:
+            return
+
+        if self.config_service is not None:
+            repo_root_str = await self.config_service.get("REPO_PATH", required=True)
+            repo_root = Path(repo_root_str)
+        elif (
+            context is not None
+            and getattr(context, "auditor_context", None) is not None
+        ):
+            repo_root = context.auditor_context.repo_path
+        elif context is not None and getattr(context, "registry", None) is not None:
+            async with context.registry.session() as session:
+                runtime_config = await ConfigService.create(session)
+                repo_root = Path(await runtime_config.get("REPO_PATH", required=True))
+        else:
+            raise RuntimeError(
+                "CoverageWatcher initialization failed: no repo root source."
+            )
+
+        self._paths = PathResolver(repo_root)
+        self.gate_check = CoverageMinimumCheck(self._paths)
+        self.state = _WatcherState(
+            self._paths.repo_root, "work/testing/watcher_state.json"
+        )
+
+    # ID: c0b0acc5-7030-458a-9b5e-45d03e9fe8ee
+    async def check_and_remediate(
+        self, context: Any, auto_remediate: bool = True
+    ) -> dict:
+        """Senses the current coverage state and reacts to violations."""
+        await self._ensure_initialized(context)
+        logger.info("📡 Coverage Watch: Sensing system state via Workflow Gate...")
+
+        # In V2.3, verify() returns a list of violation strings. Empty = Pass.
+        violations = await self.gate_check.verify(None, {})
+
+        if not violations:
+            logger.info("✅ Coverage compliant.")
+            return {"status": "compliant"}
+
+        # Analyze findings (Just take the first one for the summary)
+        violation = self._parse_violation(violations[0])
+        logger.warning("🚨 Constitutional Violation: %s", violation.message)
+
+        if not auto_remediate:
+            return {"status": "violation_detected", "violation": violation}
+
+        if self._is_in_cooldown():
+            logger.warning("⏳ Remediation cooldown active. Skipping reflex.")
+            return {"status": "cooldown"}
+
+        # TRIGGER REFLEX
+        try:
+            logger.info("🚀 Initiating coverage_remediation workflow...")
+            # Note: remediate_coverage is a high-level service from self_healing
+            result = await remediate_coverage(
+                context.cognitive_service,
+                context.auditor_context,
+                file_handler=context.file_handler,
+                repo_root=self._paths.repo_root,
+            )
+            self.state.record_success(violation)
+            return {"status": "remediated", "result": result}
+        except Exception as e:
+            logger.error("❌ Remediation failed: %s", e)
+            return {"status": "error", "error": str(e)}
+
+    def _is_in_cooldown(self) -> bool:
+        last = self.state.get_last_remediation()
+        if not last:
+            return False
+        return datetime.now() - last < timedelta(hours=_CFG.watcher_rescan_hours)
+
+    def _parse_violation(self, message: str) -> CoverageViolation:
+        """Parses the error message from CoverageMinimumCheck into a data object."""
+        # Simple extraction logic from the "Coverage too low: X% (Target: Y%)" string
+        import re
+
+        match = re.search(r"(\d+\.?\d*)%", message)
+        current = float(match.group(1)) if match else 0.0
+
+        return CoverageViolation(
+            timestamp=datetime.now(),
+            current_coverage=current,
+            required_coverage=_CFG.watcher_required_pct,
+            message=message,
+        )
+
+
+# ID: 55f5ea3e-a410-4595-97ec-6bd4d4f8641e
+async def watch_and_remediate(context: Any, auto_remediate: bool = True) -> dict:
+    """Public wrapper for the sensor loop."""
+    return await CoverageWatcher(
+        config_service=getattr(context, "config_service", None)
+    ).check_and_remediate(context, auto_remediate)