core-runtime 0.1.1__py3-none-any.whl

will/orchestration/remediation_orchestrator.py

@@ -0,0 +1,292 @@
+# src/will/orchestration/remediation_orchestrator.py
+
+"""
+Remediation Orchestrator - Will Layer
+
+CONSTITUTIONAL FIX: Orchestration logic for constitutional remediation
+
+This orchestrator makes decisions about remediation (what/when to fix).
+It was split from ConstitutionalMonitor which violated separation by doing
+both orchestration (Will) and execution (Body).
+
+Constitutional Role:
+- Will layer: Decision-making and orchestration
+- Decides what needs remediation
+- Decides when to remediate
+- Delegates execution to Body layer
+- No direct file operations
+
+Migration:
+- OLD: ConstitutionalMonitor (Mind layer) - orchestration + execution (VIOLATION)
+- NEW: RemediationOrchestrator (Will layer) - orchestration only (COMPLIANT)
+- NEW: RemediationService (Body layer) - execution only (COMPLIANT)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+from body.governance.remediation_service import (
+    RemediationResult,
+    RemediationService,
+    Violation,
+)
+from mind.governance.audit_context import AuditorContext
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: e6f558e7-0ce7-41c8-9612-82a0c2c3f0ab
+class KnowledgeGraphBuilderProtocol(Protocol):
+    """Protocol for knowledge graph builder dependency."""
+
+    # ID: 2deaf085-c14c-4f34-aa18-a660ef8aa43e
+    async def build_and_sync(self) -> None: ...
+
+
+@dataclass
+# ID: 835e78b0-af57-4a86-a29a-5bfc4dc7fbbe
+class AuditReport:
+    """Results of a constitutional audit."""
+
+    policy_category: str
+    violations: list[Violation]
+    total_files_scanned: int
+    compliant_files: int
+
+    @property
+    # ID: 418475ad-bdd8-46c2-a353-0be5976319b1
+    def has_violations(self) -> bool:
+        return len(self.violations) > 0
+
+
+# ID: f1a2b3c4-d5e6-7f8a-9b0c-1d2e3f4a5b6c
+class RemediationOrchestrator:
+    """
+    Will layer orchestrator for constitutional remediation.
+
+    CONSTITUTIONAL COMPLIANCE:
+    - Will layer: Makes decisions and orchestrates
+    - Decides what to audit
+    - Decides what to remediate
+    - Delegates execution to Body layer
+    - NO direct file operations (that's Body's job)
+
+    This orchestrator decides strategy and delegates execution.
+    It does NOT execute remediation itself.
+    """
+
+    def __init__(
+        self,
+        repo_path: Path | str,
+        knowledge_builder: KnowledgeGraphBuilderProtocol | None = None,
+    ):
+        """
+        Initialize remediation orchestrator.
+
+        Args:
+            repo_path: Root path of the repository to orchestrate
+            knowledge_builder: Optional knowledge graph builder for post-remediation
+        """
+        self.repo_path = Path(repo_path)
+        self.knowledge_builder = knowledge_builder
+
+        # Will layer: Use Mind layer for auditing (reads governance)
+        self.auditor = AuditorContext(self.repo_path)
+
+        # Will layer: Use Body layer for execution (does work)
+        self.remediation_service = RemediationService(self.repo_path)
+
+        logger.info("RemediationOrchestrator initialized for %s", self.repo_path)
+
+    # ID: de325a31-c034-401f-94f9-fb3a11899511
+    def audit_headers(self) -> AuditReport:
+        """
+        ORCHESTRATION: Decide to audit headers and collect results.
+
+        Will layer responsibility:
+        - Decides to run audit
+        - Collects results from Mind layer (AuditorContext)
+        - Formats results for decision-making
+        - Does NOT execute audit itself
+
+        Returns:
+            AuditReport with violations found
+        """
+        logger.info("Orchestrating header audit...")
+
+        # Decision: Audit all Python files
+        violations_found: list[Violation] = []
+        total_scanned = 0
+        compliant = 0
+
+        # Delegate to Mind layer: Get audit results
+        src_path = self.repo_path / "src"
+        if src_path.exists():
+            for py_file in src_path.rglob("*.py"):
+                total_scanned += 1
+
+                # Mind layer tells us: Does this file have violations?
+                has_violation = self.auditor.check_file_header(str(py_file))
+
+                if has_violation:
+                    # Decision: Record this as needing remediation
+                    violations_found.append(
+                        Violation(
+                            file_path=str(py_file),
+                            policy_id="code.headers.required",
+                            description="Missing required header",
+                            severity="warning",
+                            remediation_handler="add_header",
+                        )
+                    )
+                else:
+                    compliant += 1
+
+        logger.info(
+            "Audit complete: %d scanned, %d violations, %d compliant",
+            total_scanned,
+            len(violations_found),
+            compliant,
+        )
+
+        return AuditReport(
+            policy_category="headers",
+            violations=violations_found,
+            total_files_scanned=total_scanned,
+            compliant_files=compliant,
+        )
+
+    # ID: 79e49dd2-5885-4bde-ade2-51bf7614f67b
+    async def remediate_missing_headers_async(self) -> RemediationResult:
+        """
+        ORCHESTRATION: Decide to remediate headers and coordinate execution.
+
+        Will layer responsibility:
+        - Decides to find violations (calls audit)
+        - Decides to remediate them
+        - Delegates execution to Body layer
+        - Decides post-remediation actions (knowledge graph update)
+        - Does NOT execute remediation itself
+
+        Returns:
+            RemediationResult with execution results from Body layer
+        """
+        logger.info("Orchestrating header remediation...")
+
+        # Decision 1: Audit to find violations
+        audit_report = self.audit_headers()
+
+        if not audit_report.has_violations:
+            logger.info("No violations found, no remediation needed")
+            return RemediationResult(
+                success=True, fixed_count=0, failed_count=0, error=None
+            )
+
+        logger.info("Found %d violations to remediate", len(audit_report.violations))
+
+        # Decision 2: Delegate execution to Body layer
+        result = await self.remediation_service.remediate_missing_headers(
+            audit_report.violations
+        )
+
+        # Decision 3: Update knowledge graph if remediation succeeded
+        if result.success and self.knowledge_builder:
+            logger.info("Orchestrating knowledge graph update after remediation...")
+            try:
+                await self.knowledge_builder.build_and_sync()
+                logger.info("Knowledge graph updated successfully")
+            except Exception as e:
+                logger.error("Failed to update knowledge graph: %s", e)
+                # Don't fail the whole operation if KG update fails
+
+        logger.info(
+            "Remediation orchestration complete: %d fixed, %d failed",
+            result.fixed_count,
+            result.failed_count,
+        )
+
+        return result
+
+    # ID: c4d5e6f7-a8b9-0c1d-2e3f-4a5b6c7d8e9f
+    async def remediate_single_file_async(self, file_path: str) -> bool:
+        """
+        ORCHESTRATION: Decide to remediate single file and delegate execution.
+
+        Will layer responsibility:
+        - Decides to remediate specific file
+        - Delegates execution to Body layer
+        - Decides whether to update knowledge graph
+        - Does NOT execute remediation itself
+
+        Args:
+            file_path: Path to file to remediate
+
+        Returns:
+            True if remediation succeeded, False otherwise
+        """
+        logger.info("Orchestrating remediation for: %s", file_path)
+
+        # Decision 1: Delegate execution to Body layer
+        success = await self.remediation_service.remediate_single_file(file_path)
+
+        # Decision 2: Update knowledge graph if needed
+        if success and self.knowledge_builder:
+            logger.info("Orchestrating knowledge graph update for: %s", file_path)
+            try:
+                await self.knowledge_builder.build_and_sync()
+            except Exception as e:
+                logger.error("Failed to update knowledge graph: %s", e)
+
+        return success
+
+    # ID: d5e6f7a8-b9c0-1d2e-3f4a-5b6c7d8e9f0a
+    def validate_remediation(self, file_path: str) -> bool:
+        """
+        ORCHESTRATION: Decide to validate remediation and delegate check.
+
+        Will layer responsibility:
+        - Decides to validate specific file
+        - Delegates validation to Body layer
+        - Does NOT execute validation itself
+
+        Args:
+            file_path: Path to file to validate
+
+        Returns:
+            True if file is compliant, False otherwise
+        """
+        logger.info("Orchestrating validation for: %s", file_path)
+
+        # Delegate to Body layer
+        return self.remediation_service.validate_remediation(file_path)
+
+
+# ID: e6f7a8b9-c0d1-2e3f-4a5b-6c7d8e9f0a1b
+def get_remediation_orchestrator(
+    repo_path: Path | str | None = None,
+    knowledge_builder: KnowledgeGraphBuilderProtocol | None = None,
+) -> RemediationOrchestrator:
+    """
+    Factory function for remediation orchestrator.
+
+    Args:
+        repo_path: Optional repository path (defaults to current directory)
+        knowledge_builder: Optional knowledge graph builder
+
+    Returns:
+        RemediationOrchestrator instance
+
+    Usage:
+        # Will layer: Orchestrate remediation
+        orchestrator = get_remediation_orchestrator()
+        result = await orchestrator.remediate_missing_headers_async()
+    """
+    if repo_path is None:
+        repo_path = Path.cwd()
+
+    return RemediationOrchestrator(repo_path, knowledge_builder)

will/orchestration/self_correction_engine.py

@@ -0,0 +1,154 @@
+# src/will/orchestration/self_correction_engine.py
+
+"""
+Handles automated correction of code failures by generating and validating LLM-suggested repairs.
+Updated for A3: Scans source code for imports to resolve ImportErrors intelligently.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import TYPE_CHECKING, Any
+
+from shared.ai.prompt_model import PromptModel
+from shared.logger import getLogger
+from shared.path_resolver import PathResolver
+from shared.utils.parsing import parse_write_blocks
+from will.orchestration.cognitive_service import CognitiveService
+from will.orchestration.prompt_pipeline import PromptPipeline
+from will.orchestration.validation_pipeline import validate_code_async
+from will.tools.symbol_finder import SymbolFinder
+
+
+if TYPE_CHECKING:
+    from mind.governance.audit_context import AuditorContext
+logger = getLogger(__name__)
+
+
+def _build_pipeline(path_resolver: PathResolver) -> PromptPipeline:
+    return PromptPipeline(repo_path=path_resolver.repo_root)
+
+
+def _extract_imports_from_code(code: str) -> set[str]:
+    """
+    Extracts symbol names being imported in the code.
+    Handles:
+      from module import Symbol
+      import Module
+    """
+    symbols = set()
+    from_pattern = re.compile("^\\s*from\\s+[\\w.]+\\s+import\\s+(.+)$", re.MULTILINE)
+    for match in from_pattern.finditer(code):
+        imports_str = match.group(1)
+        if "#" in imports_str:
+            imports_str = imports_str.split("#")[0]
+        for part in imports_str.split(","):
+            part = part.strip()
+            if not part:
+                continue
+            symbol = part.split(" as ")[0].strip()
+            if symbol:
+                symbols.add(symbol)
+    return symbols
+
+
+# ID: 86fe9933-85e9-4a36-bfe5-3b529e4b266a
+async def attempt_correction(
+    failure_context: dict[str, Any],
+    cognitive_service: CognitiveService,
+    auditor_context: AuditorContext,
+    path_resolver: PathResolver,
+) -> dict[str, Any]:
+    """
+    Attempts to fix a failed validation or test result using an enriched LLM prompt.
+    Now includes deep symbol lookup for ImportErrors by analyzing the code.
+    """
+    pipeline = _build_pipeline(path_resolver)
+    model = PromptModel.load("self_correction_engine_correction_prompt")
+    generator = await cognitive_service.aget_client_for_role(model.manifest.role)
+    file_path = failure_context.get("file_path")
+    code = failure_context.get("code")
+    violations = failure_context.get("violations", [])
+    runtime_error = failure_context.get("runtime_error", "")
+    if not all([file_path, code]):
+        return {
+            "status": "error",
+            "message": "Missing required failure context fields (file_path, code).",
+        }
+    symbol_hints = ""
+    if runtime_error and (
+        "ImportError" in runtime_error or "ModuleNotFoundError" in runtime_error
+    ):
+        logger.info("Import error detected. analyzing code for missing symbols...")
+        try:
+            finder = SymbolFinder()
+            error_line = next(
+                (line for line in runtime_error.split("\n") if "Error" in line),
+                runtime_error,
+            )
+            base_hints = await finder.get_context_for_import_error(error_line)
+            imported_symbols = _extract_imports_from_code(code)
+            deep_hints = []
+            if imported_symbols:
+                logger.info(
+                    "Scanning Knowledge Graph for imported symbols: %s",
+                    imported_symbols,
+                )
+                for symbol in imported_symbols:
+                    matches = await finder.find_symbol(symbol, limit=3)
+                    for m in matches:
+                        deep_hints.append(
+                            f"  - Found '{m.name}' in '{m.module}' (Use: {m.import_statement})"
+                        )
+            all_hints_text = base_hints
+            if deep_hints:
+                all_hints_text += "\n\nFound in Knowledge Graph:\n" + "\n".join(
+                    deep_hints
+                )
+            symbol_hints = all_hints_text
+            if symbol_hints:
+                logger.info("Generated symbol hints: %s chars", len(symbol_hints))
+        except Exception as e:
+            logger.warning("SymbolFinder failed: %s", e)
+    violations_json = json.dumps(violations, indent=2)
+    hint_section = ""
+    if symbol_hints:
+        hint_section = f"\n# INTELLIGENT HINTS (FROM KNOWLEDGE GRAPH)\n{symbol_hints}\n"
+    final_prompt = pipeline.process("")
+    try:
+        llm_output = await model.invoke(
+            context={
+                "file_path": file_path,
+                "violations_json": violations_json,
+                "runtime_error": runtime_error,
+                "hint_section": hint_section,
+                "code": code.strip(),
+            },
+            client=generator,
+            user_id="auto_repair",
+        )
+    except Exception as e:
+        return {"status": "error", "message": f"LLM request failed: {e!s}"}
+    write_blocks = parse_write_blocks(llm_output)
+    if not write_blocks:
+        return {
+            "status": "error",
+            "message": "LLM did not produce a valid correction in a write block.",
+        }
+    path, fixed_code = next(iter(write_blocks.items()))
+    validation_result = await validate_code_async(
+        path, fixed_code, auditor_context=auditor_context
+    )
+    if validation_result["status"] == "dirty":
+        return {
+            "status": "correction_failed_validation",
+            "message": "The corrected code still fails validation.",
+            "violations": validation_result["violations"],
+            "code": fixed_code,
+        }
+    return {
+        "status": "success",
+        "code": validation_result["code"],
+        "message": "Corrected code generated and validated successfully.",
+    }

will/orchestration/validation_pipeline.py

@@ -0,0 +1,45 @@
+# src/will/orchestration/validation_pipeline.py
+
+"""
+A context-aware validation pipeline that applies different validation steps based on file type.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from body.services.validation.python_validator import validate_python_code_async
+from shared.infrastructure.storage.file_classifier import get_file_classification
+from shared.infrastructure.validation.yaml_validator import validate_yaml_code
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from mind.governance.audit_context import AuditorContext
+logger = getLogger(__name__)
+
+
+# ID: 49007f0d-d279-449b-9a47-da13fb6a0a5e
+async def validate_code_async(
+    file_path: str,
+    code: str,
+    quiet: bool = False,
+    auditor_context: AuditorContext | None = None,
+) -> dict[str, Any]:
+    """Validate a file's code by routing it to the appropriate validation pipeline."""
+    classification = get_file_classification(file_path)
+    if not quiet:
+        logger.debug("Validation: Classifying '{file_path}' as '%s'.", classification)
+    final_code = code
+    violations = []
+    if classification == "python":
+        if not auditor_context:
+            raise ValueError("AuditorContext is required for validating Python code.")
+        final_code, violations = await validate_python_code_async(
+            file_path, code, auditor_context
+        )
+    elif classification == "yaml":
+        final_code, violations = validate_yaml_code(code)
+    is_dirty = any(v.get("severity") == "error" for v in violations)
+    status = "dirty" if is_dirty else "clean"
+    return {"status": status, "violations": violations, "code": final_code}