core-runtime 0.1.1__py3-none-any.whl

body/evaluators/base_evaluator.py

@@ -0,0 +1,67 @@
+# src/body/evaluators/base_evaluator.py
+"""Base Evaluator Contract - The "Judge" Interface.
+
+PURIFIED (V2.3.0)
+- Removed Will-layer 'DecisionTracer' to satisfy architecture.layers.no_body_to_will.
+- Reasoning is now stored in ComponentResult metadata for Will-layer consumption.
+- Removed automatic save_trace; Body components must be stateless fact producers.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from shared.component_primitive import ComponentPhase, ComponentResult
+from shared.context import CoreContext
+
+
+# ID: 078fdd48-815b-446e-936b-f0a12846a2ea
+class BaseEvaluator(ABC):
+    """Base contract for all evaluators operating in the AUDIT phase."""
+
+    def __init__(self, context: CoreContext | None = None) -> None:
+        self.context = context
+
+    @property
+    @abstractmethod
+    # ID: f6a5e1cf-96eb-436f-8c94-611e429db6f8
+    def component_id(self) -> str:
+        """Unique identifier for this evaluator."""
+
+    @property
+    # ID: 9062c5d4-f7db-44ff-ad27-f98758061cb9
+    def phase(self) -> ComponentPhase:
+        """All evaluators operate in the AUDIT phase."""
+        from shared.component_primitive import ComponentPhase
+
+        return ComponentPhase.AUDIT
+
+    @abstractmethod
+    # ID: fd232b4d-4cc7-4c80-8e2a-dca89d96b16b
+    async def evaluate(self, *args: Any, **kwargs: Any) -> ComponentResult:
+        """Execute evaluation and return structured result."""
+
+    async def _create_result(
+        self,
+        ok: bool,
+        data: dict[str, Any],
+        confidence: float,
+        duration: float,
+        rationale: str | None = None,
+    ) -> ComponentResult:
+        """Structure results and embed rationale into metadata."""
+        metadata = data.get("metadata", {})
+
+        if rationale:
+            metadata["rationale"] = rationale
+
+        return ComponentResult(
+            component_id=self.component_id,
+            ok=ok,
+            data=data,
+            phase=self.phase,
+            confidence=confidence,
+            duration_sec=duration,
+            metadata=metadata,
+        )

body/evaluators/clarity_evaluator.py

@@ -0,0 +1,83 @@
+# src/body/evaluators/clarity_evaluator.py
+
+"""
+Clarity Evaluator - Measures mathematical improvement in code structure.
+CONSTITUTIONAL PROMOTION: Fulfilled BaseEvaluator contract.
+"""
+
+from __future__ import annotations
+
+import time
+
+from radon.visitors import ComplexityVisitor
+
+from shared.component_primitive import ComponentResult
+from shared.logger import getLogger
+
+from .base_evaluator import BaseEvaluator
+
+
+logger = getLogger(__name__)
+
+
+# ID: d4aa43cb-e62b-4a50-b34e-9aa12144a561
+class ClarityEvaluator(BaseEvaluator):
+    """Evaluate refactoring results by comparing Cyclomatic Complexity (CC)."""
+
+    @property
+    # ID: 04c638f6-5c8b-4ea4-a80e-39b607fec1e2
+    def component_id(self) -> str:
+        return "clarity_evaluator"
+
+    # phase is inherited from BaseEvaluator — all evaluators are AUDIT phase.
+
+    # ID: c35226bd-1d63-46fc-9ceb-f3c5a1d63208
+    async def evaluate(
+        self, original_code: str, new_code: str, **kwargs
+    ) -> ComponentResult:
+        """
+        Calculates the improvement ratio between two versions of code.
+        Implementation of the abstract 'evaluate' method.
+        """
+        start_time = time.time()
+
+        try:
+            # 1. Sensation: Analyze original
+            orig_visitor = ComplexityVisitor.from_code(original_code)
+            orig_cc = sum(block.complexity for block in orig_visitor.blocks)
+
+            # 2. Sensation: Analyze proposed
+            new_visitor = ComplexityVisitor.from_code(new_code)
+            new_cc = sum(block.complexity for block in new_visitor.blocks)
+
+            # 3. Analysis: Calculate metrics
+            improvement = (orig_cc - new_cc) / orig_cc if orig_cc > 0 else 0.0
+            is_better = new_cc < orig_cc  # Must be strictly better
+
+            duration = time.time() - start_time
+
+            return await self._create_result(
+                ok=True,
+                data={
+                    "original_cc": orig_cc,
+                    "new_cc": new_cc,
+                    "improvement_ratio": round(improvement, 4),
+                    "is_better": is_better,
+                },
+                confidence=1.0,
+                duration=duration,
+                rationale=(
+                    f"Quality Assessment: Original CC {orig_cc} -> New CC {new_cc}. "
+                    f"Improved: {is_better}"
+                ),
+            )
+
+        except Exception as e:
+            logger.error("ClarityEvaluator: analysis failed: %s", e, exc_info=True)
+            return await self._create_result(
+                ok=False,
+                data={"error": f"Radon analysis failed: {e!s}"},
+                confidence=0.0,
+                duration=time.time() - start_time,
+                rationale="Failed to perform radon complexity analysis.",
+            )

body/evaluators/constitutional_evaluator.py

@@ -0,0 +1,227 @@
+# src/body/evaluators/constitutional_evaluator.py
+
+"""
+ConstitutionalEvaluator - Assesses constitutional policy compliance.
+
+CONSTITUTIONAL COMPLIANCE:
+- Uses AuditorContext for all governance checks (Mind layer access)
+- Evaluates files against rules from .intent/ structure
+- No direct filesystem access to .intent/
+- Maintains Mind/Body separation
+
+CONSTITUTIONAL FIX (V2.3):
+- Removed unused variable 'target_content' (workflow.dead_code_check).
+- Maintains Mind/Body separation: Evaluates rules using the AuditorContext.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+from shared.component_primitive import Component, ComponentPhase, ComponentResult
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: c935569b-95cd-4ee1-8128-ffdbb8f490e2
+class ConstitutionalEvaluator(Component):
+    """
+    Evaluates constitutional compliance for files and operations.
+
+    Checks against:
+    - Constitutional rules from .intent/rules/
+    - Constitutional principles from .intent/constitution/
+    - Architectural patterns from .intent/enforcement/mappings/
+    - Governance boundaries (no .intent/ writes, etc.)
+
+    Returns:
+    - Binary compliance status (ok: True/False)
+    - List of violations with details
+    - Compliance score (confidence metric)
+    - Remediation context
+    """
+
+    def __init__(self):
+        """Initialize evaluator with lazy-loaded governance components."""
+        self._validator_service = None
+
+    @property
+    # ID: e947509f-0965-4723-8997-0b0e55143a81
+    def phase(self) -> ComponentPhase:
+        """ConstitutionalEvaluator operates in AUDIT phase."""
+        return ComponentPhase.AUDIT
+
+    @property
+    # ID: a7173a43-ebca-4bba-9512-17b69d01ddce
+    def validator_service(self):
+        """Lazy-load ConstitutionalValidator to avoid circular imports."""
+        if self._validator_service is None:
+            from body.services.constitutional_validator import get_validator
+
+            self._validator_service = get_validator()
+        return self._validator_service
+
+    # ID: 4770d6fd-6014-4593-9d7c-ae978cedaedf
+    async def execute(
+        self,
+        repo_root: Path,
+        file_path: str | None = None,
+        operation_type: str | None = None,
+        validation_scope: list[str] | None = None,
+        **kwargs: Any,
+    ) -> ComponentResult:
+        """
+        Evaluate constitutional compliance for a file or operation.
+
+        Args:
+            repo_root: Repository root path
+            file_path: Optional path to file being evaluated
+            operation_type: Optional type of operation (refactor, create, etc.)
+            validation_scope: Optional list of validation types to perform
+            **kwargs: Additional evaluation parameters
+
+        Returns:
+            ComponentResult with compliance status and violations
+        """
+        start_time = time.time()
+
+        from mind.governance.audit_context import AuditorContext
+
+        auditor_context = AuditorContext(repo_root)
+
+        violations = []
+        details = {}
+
+        try:
+            scope = validation_scope or [
+                "constitutional_compliance",
+                "pattern_compliance",
+                "governance_boundaries",
+            ]
+
+            if "constitutional_compliance" in scope:
+                const_violations = await self._check_constitutional_compliance(
+                    auditor_context, file_path
+                )
+                violations.extend(const_violations)
+                details["constitutional"] = {
+                    "checked": True,
+                    "violations": len(const_violations),
+                }
+
+            if "pattern_compliance" in scope and file_path:
+                pattern_violations = await self._check_pattern_compliance(
+                    repo_root, file_path
+                )
+                violations.extend(pattern_violations)
+                details["patterns"] = {
+                    "checked": True,
+                    "violations": len(pattern_violations),
+                }
+
+            # Determine if evaluation passes
+            ok = (
+                len(
+                    [
+                        v
+                        for v in violations
+                        if v.get("severity") in ["critical", "error"]
+                    ]
+                )
+                == 0
+            )
+
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=ok,
+                phase=self.phase,
+                data={
+                    "violations": violations,
+                    "details": details,
+                    "evaluation_scope": scope,
+                },
+                confidence=1.0 if ok else 0.5,
+                duration_sec=time.time() - start_time,
+            )
+
+        except Exception as e:
+            logger.error("ConstitutionalEvaluator failed: %s", e, exc_info=True)
+            return ComponentResult(
+                component_id=self.component_id,
+                ok=False,
+                phase=self.phase,
+                data={"error": str(e)},
+                confidence=0.0,
+                duration_sec=time.time() - start_time,
+            )
+
+    async def _check_constitutional_compliance(
+        self, auditor_context: Any, file_path: str | None
+    ) -> list[dict[str, Any]]:
+        """
+        Check file against constitutional rules via AuditorContext.
+
+        Args:
+            auditor_context: AuditorContext for governance access
+            file_path: Path to file being checked
+
+        Returns:
+            List of violation dicts
+        """
+        if not file_path:
+            return []
+        try:
+            await auditor_context.load_knowledge_graph()
+            from mind.governance.filtered_audit import run_filtered_audit
+
+            findings, _, _ = await run_filtered_audit(
+                auditor_context, rule_patterns=[r".*"]
+            )
+            return [
+                {
+                    "type": "constitutional",
+                    "rule_id": f.get("rule_id", "unknown"),
+                    "severity": f.get("severity", "error"),
+                    "message": f.get("message", "Violation"),
+                    "file_path": file_path,
+                }
+                for f in findings
+                if f.get("file_path") == str(file_path)
+            ]
+        except Exception:
+            return []
+
+    async def _check_pattern_compliance(
+        self, repo_root: Path, file_path: str
+    ) -> list[dict[str, Any]]:
+        """
+        Check file against architectural patterns.
+
+        Args:
+            repo_root: Repository root path
+            file_path: Path to file being checked
+
+        Returns:
+            List of pattern violation dicts
+        """
+        violations = []
+        if "src/body/atomic/" in file_path:
+            from body.evaluators.atomic_actions_evaluator import AtomicActionsEvaluator
+
+            evaluator = AtomicActionsEvaluator()
+            action_violations, _ = evaluator._check_file(repo_root / file_path)
+            for v in action_violations:
+                violations.append(
+                    {
+                        "type": "pattern",
+                        "rule_id": v.rule_id,
+                        "severity": v.severity,
+                        "message": v.message,
+                        "file_path": file_path,
+                    }
+                )
+        return violations

body/evaluators/failure_evaluator.py

@@ -0,0 +1,136 @@
+# src/body/evaluators/failure_evaluator.py
+"""Failure Evaluator - Analyzes test failure patterns for strategy adaptation.
+
+PURIFIED (V2.3.0)
+- Removed Will-layer 'DecisionTracer' to satisfy layer separation.
+- Pivot recommendations and patterns returned in data/metadata for the Strategist.
+"""
+
+from __future__ import annotations
+
+import time
+from collections import Counter
+
+# from shared.component_primitive import Component, ComponentPhase, ComponentResult
+from body.evaluators.base_evaluator import BaseEvaluator
+from shared.component_primitive import ComponentResult
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: ef17c136-eb2b-4756-8eef-635c7ddc9546
+class FailureEvaluator(BaseEvaluator):
+    """Analyze test failure strings to identify recurring patterns.
+
+    Enables the Will layer to adapt strategies based on observed Body failures.
+    """
+
+    # ID: 31ed733a-6ed4-429a-bb5d-f1612a589104
+    async def execute(
+        self,
+        error: str,
+        pattern_history: list[str] | None = None,
+        **kwargs,
+    ) -> ComponentResult:
+        """Evaluate a single failure and recommend an adaptive action."""
+        start_time = time.time()
+        history = list(pattern_history or [])
+
+        # 1) Pattern extraction
+        pattern = self._extract_pattern(error)
+        history.append(pattern)
+
+        pattern_counts = Counter(history)
+        occurrences = pattern_counts[pattern]
+
+        # 2) Strategy mapping
+        if occurrences >= 3:
+            recommendation = "switch_strategy"
+            should_switch = True
+            confidence = 0.95
+            next_suggested = "test_strategist"
+        elif occurrences == 2:
+            recommendation = "adjust_prompt"
+            should_switch = False
+            confidence = 0.7
+            next_suggested = "test_generator"
+        else:
+            recommendation = "retry"
+            should_switch = False
+            confidence = 0.5
+            next_suggested = "test_generator"
+
+        duration = time.time() - start_time
+
+        # 3) Metadata carrier: replaces direct tracing
+        return ComponentResult(
+            component_id=self.component_id,
+            ok=True,
+            data={
+                "pattern": pattern,
+                "occurrences": occurrences,
+                "should_switch": should_switch,
+                "recommendation": recommendation,
+            },
+            phase=self.phase,
+            confidence=confidence,
+            next_suggested=next_suggested,
+            duration_sec=duration,
+            metadata={
+                "pattern_history": history,
+                "rationale": (
+                    f"Observed pattern '{pattern}' (Count: {occurrences}). "
+                    f"Recommending: {recommendation}"
+                ),
+                "summary": self.get_pattern_summary(history),
+            },
+        )
+
+    def _extract_pattern(self, error: str) -> str:
+        err_lower = error.lower()
+
+        if "modulenotfounderror" in err_lower or "importerror" in err_lower:
+            return "invalid_import"
+        if "nameerror" in err_lower:
+            return "logic_error_missing_name"
+        if "isinstance" in err_lower and (
+            "classvar" in err_lower or "mapped" in err_lower
+        ):
+            return "type_introspection"
+        if "attributeerror" in err_lower:
+            return (
+                "mock_placement" if "mock" in err_lower else "attribute_error_generic"
+            )
+        if "assertionerror" in err_lower:
+            return (
+                "object_identity_comparison"
+                if "0x" in err_lower
+                else "assertion_comparison"
+            )
+        if "sqlalchemy" in err_lower:
+            return (
+                "sqlalchemy_session" if "session" in err_lower else "sqlalchemy_generic"
+            )
+        if "timeout" in err_lower:
+            return "test_timeout"
+        if "fixture" in err_lower:
+            return "fixture_error"
+
+        return "unknown"
+
+    # ID: beb602c2-ebd9-4f2a-bc53-8009101556eb
+    def get_pattern_summary(self, pattern_history: list[str]) -> dict:
+        if not pattern_history:
+            return {"total": 0, "unique": 0, "patterns": {}}
+
+        counts = Counter(pattern_history)
+        most_common = counts.most_common(1)[0][0] if counts else None
+
+        return {
+            "total": len(pattern_history),
+            "unique": len(counts),
+            "most_common": most_common,
+            "patterns": dict(counts),
+        }