core-runtime 0.1.1__py3-none-any.whl

will/self_healing/alignment/sandbox.py

@@ -0,0 +1,51 @@
+# src/will/self_healing/alignment/sandbox.py
+
+"""Refactored logic for src/features/self_healing/alignment/sandbox.py."""
+
+from __future__ import annotations
+
+import asyncio
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from shared.infrastructure.config_service import ConfigService
+
+
+# ID: 561ad23f-b5dd-4bf2-b1e1-c9c966de110e
+async def verify_import_safety(
+    file_path: str, config_service: ConfigService
+) -> tuple[bool, str]:
+    """Sandbox test to ensure the file is 'compilable'."""
+    module_path = file_path.replace("src/", "").replace(".py", "").replace("/", ".")
+    check_code = f"import {module_path}\nprint('ALIVE')"
+
+    # CLAUDE.md /tmp/ prohibition: temp file must resolve inside the repo under var/tmp/.
+    repo_root = Path(await config_service.get("REPO_PATH", required=True))
+
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        suffix=".py",
+        delete=False,
+        dir=str(repo_root / "var" / "tmp"),
+    ) as f:
+        f.write(check_code)
+        temp_path = f.name
+
+    try:
+        src_path = str((repo_root / "src").resolve())
+        proc = await asyncio.create_subprocess_exec(
+            "env",
+            f"PYTHONPATH={src_path}",
+            "python3",
+            temp_path,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=str(repo_root),
+        )
+        _, stderr = await proc.communicate()
+        return (proc.returncode == 0, stderr.decode("utf-8"))
+    finally:
+        await asyncio.to_thread(Path(temp_path).unlink, missing_ok=True)

will/self_healing/alignment/specialists.py

@@ -0,0 +1,165 @@
+# src/will/self_healing/alignment/specialists.py
+
+"""Refactored logic for src/features/self_healing/alignment/specialists.py."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from shared.ai.prompt_model import PromptModel
+from shared.logger import getLogger
+from shared.utils.parsing import extract_python_code_from_response, parse_write_blocks
+
+
+if TYPE_CHECKING:
+    from shared.infrastructure.config_service import ConfigService
+
+logger = getLogger(__name__)
+
+
+# ID: db02b8db-97e9-4b1a-9f08-d49da0271b6d
+class SpecialistDispatcher:
+    def __init__(self, cognitive_service, symbol_finder, config_service: ConfigService):
+        self.cognitive = cognitive_service
+        self.symbol_finder = symbol_finder
+        self.config_service = config_service
+
+    async def _repo_root(self) -> Path:
+        return Path(await self.config_service.get("REPO_PATH", required=True))
+
+    async def _prompt_path(self, prompt_name: str) -> Path:
+        repo_root = await self._repo_root()
+        safe = prompt_name.strip().replace("\\", "/").split("/")[-1]
+        return repo_root / "var" / "prompts" / f"{safe}.prompt"
+
+    # ID: 3415c10d-1be1-4113-88db-9c3c57443219
+    async def trigger_modularizer(self, file_path: str, write: bool) -> bool:
+        """Agentic healing for God Objects."""
+        logger.info("? God Object detected. Triggering Modularizer Specialist...")
+        repo_root = await self._repo_root()
+        source_code = await asyncio.to_thread(
+            (repo_root / file_path).read_text, encoding="utf-8"
+        )
+
+        model = PromptModel.load("godd_object_modularizer")
+        agent = await self.cognitive.aget_client_for_role(model.manifest.role)
+        response = await model.invoke(
+            context={
+                "file_path": file_path,
+                "current_lines": len(source_code.splitlines()),
+                "max_lines": 400,
+                "source_code": source_code,
+            },
+            client=agent,
+            user_id="police_agent_modularizer",
+        )
+
+        blocks = parse_write_blocks(response)
+        if not blocks:
+            return False
+        if write:
+            for path, content in blocks.items():
+                await asyncio.to_thread(
+                    (repo_root / path).write_text, content, encoding="utf-8"
+                )
+                logger.info("? Modularizer: Created/Updated %s", path)
+            return True
+        return False
+
+    # ID: 46794206-c8f9-4c68-b52b-f3bdb74620d7
+    async def trigger_logic_repair(
+        self, file_path: str, error_msg: str, write: bool
+    ) -> bool:
+        """Agentic healing for broken imports/drift."""
+        logger.info("? Logic drift detected. Triggering Logic Specialist...")
+        repo_root = await self._repo_root()
+        hints = await self.symbol_finder.get_context_for_import_error(error_msg)
+        source_code = await asyncio.to_thread(
+            (repo_root / file_path).read_text, encoding="utf-8"
+        )
+
+        model = PromptModel.load("logic_alignment_generic_repair")
+        agent = await self.cognitive.aget_client_for_role(model.manifest.role)
+        response = await model.invoke(
+            context={
+                "file_path": file_path,
+                "error_message": error_msg,
+                "symbol_hints": hints or "Use architectural standards.",
+                "source_code": source_code,
+            },
+            client=agent,
+            user_id="police_agent_logic",
+        )
+        fixed_code = extract_python_code_from_response(response)
+
+        if fixed_code and write:
+            await asyncio.to_thread(
+                (repo_root / file_path).write_text,
+                fixed_code,
+                encoding="utf-8",
+            )
+            logger.info("? Logic Specialist: Repaired imports in %s", file_path)
+            return True
+        return False
+
+    # ID: b898a0d4-600e-437f-8a91-a787872b82e9
+    async def trigger_generic_repair(
+        self, file_path: str, violation: dict, write: bool
+    ) -> bool:
+        """Generic healing for violations not covered by specific handlers."""
+        repo_root = await self._repo_root()
+        source_code = await asyncio.to_thread(
+            (repo_root / file_path).read_text, encoding="utf-8"
+        )
+
+        violation_details = f"Rule: {violation.get('check_id')}\nSeverity: {violation.get('severity')}\nMessage: {violation.get('message')}\nLine: {violation.get('line_number', 'none')}"
+
+        model = PromptModel.load("logic_alignment_generic_repair")
+        agent = await self.cognitive.aget_client_for_role(model.manifest.role)
+        response = await model.invoke(
+            context={
+                "file_path": file_path,
+                "error_message": violation_details,
+                "symbol_hints": "Search codebase for similar implementations.",
+                "source_code": source_code,
+            },
+            client=agent,
+            user_id="police_agent_generic",
+        )
+        fixed_code = extract_python_code_from_response(response)
+
+        if fixed_code and write:
+            await asyncio.to_thread(
+                (repo_root / file_path).write_text,
+                fixed_code,
+                encoding="utf-8",
+            )
+            return True
+        return False
+
+    # ID: d199fc8c-45b6-445b-b879-7af3c38138cc
+    async def heal_structural_clerk(
+        self, file_path: str, task: str, write: bool
+    ) -> bool:
+        """Deterministic healing for metadata."""
+        repo_root = await self._repo_root()
+        if not write:
+            return False
+        if task == "header":
+            from body.self_healing.header_service import HeaderService
+
+            await asyncio.to_thread(
+                HeaderService(repo_root=repo_root)._fix,
+                [str(repo_root / file_path)],
+            )
+            return True
+        if task == "ids":
+            from body.self_healing.id_tagging_service import assign_missing_ids
+
+            await assign_missing_ids(
+                context=None, write=False
+            )  # Context handled by Registry
+            return True
+        return False

will/self_healing/alignment_orchestrator.py

@@ -0,0 +1,140 @@
+# src/will/self_healing/alignment_orchestrator.py
+
+"""
+AlignmentOrchestrator (The Police Agent)
+Enforces Constitutional Integrity at the file level. Refactored (V2.3).
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+from shared.infrastructure.config_service import ConfigService
+from shared.logger import getLogger
+from will.orchestration.cognitive_service import CognitiveService
+from will.tools.symbol_finder import SymbolFinder
+
+from .alignment.persistence import record_action_result, update_system_memory
+from .alignment.sandbox import verify_import_safety
+from .alignment.specialists import SpecialistDispatcher
+
+
+logger = getLogger(__name__)
+
+
+# ID: e776b3ae-a7b1-4737-adcd-bf9714a35543
+class AlignmentOrchestrator:
+    """This class orchestrates the alignment process for documents using a cognitive service and configuration service. It initializes with a CognitiveService instance, a ConfigService instance, a SymbolFinder instance, and a SpecialistDispatcher instance. The align_file method takes a file path and an optional write flag to perform document alignment and optionally write results to a file."""
+
+    def __init__(
+        self,
+        cognitive_service: CognitiveService,
+        config_service: ConfigService,
+    ):
+        """Initializes a governance agent with cognitive and configuration services. It sets up symbol finding and dispatcher components. The `align_file` method inspects a file and returns audit results."""
+        self.cognitive = cognitive_service
+        self.config_service = config_service
+        self.symbol_finder = SymbolFinder()
+        self.dispatcher = SpecialistDispatcher(
+            cognitive_service, self.symbol_finder, config_service
+        )
+
+    # ID: bd0aa07e-317d-4443-9c93-424254093cd5
+    async def align_file(self, file_path: str, write: bool = False) -> dict[str, Any]:
+        """Aligns a file by checking for violations and ensuring import safety. If `write` is True, it also writes the aligned content to disk. Returns a dictionary with findings and audit results."""
+        start_time = time.time()
+        logger.info("👮 Police Agent: Inspecting %s (write_mode=%s)", file_path, write)
+
+        from mind.governance.audit_context import AuditorContext
+        from mind.governance.filtered_audit import run_filtered_audit
+
+        # 1. THE WARRANT
+        repo_root = Path(await self.config_service.get("REPO_PATH", required=True))
+        auditor_ctx = AuditorContext(repo_root)
+        findings, _, _ = await run_filtered_audit(auditor_ctx, rule_patterns=[r".*"])
+        file_violations = [
+            f
+            for f in findings
+            if f.get("file_path") == file_path
+            and "engine_missing" not in str(f.get("check_id"))
+        ]
+
+        is_importable, current_error = await verify_import_safety(
+            file_path, self.config_service
+        )
+
+        if not file_violations and is_importable:
+            logger.info("✅ %s is 100%% Aligned.", file_path)
+            await record_action_result(
+                file_path=file_path,
+                ok=True,
+                duration_ms=int((time.time() - start_time) * 1000),
+                action_metadata={"violations_found": 0, "already_compliant": True},
+            )
+            return {"status": "compliant", "file": file_path}
+
+        # 2. THE ACTION
+        modified, errors = False, []
+        for violation in file_violations:
+            rule_id = violation.get("check_id")
+            try:
+                if rule_id == "code_standards.max_file_lines":
+                    if await self.dispatcher.trigger_modularizer(file_path, write):
+                        modified = True
+                elif rule_id == "layout.src_module_header":
+                    if await self.dispatcher.heal_structural_clerk(
+                        file_path, "header", write
+                    ):
+                        modified = True
+                elif rule_id == "linkage.assign_ids":
+                    if await self.dispatcher.heal_structural_clerk(
+                        file_path, "ids", write
+                    ):
+                        modified = True
+                else:
+                    if await self.dispatcher.trigger_generic_repair(
+                        file_path, violation, write
+                    ):
+                        modified = True
+            except Exception as e:
+                errors.append(f"Failed to heal {rule_id}: {e}")
+
+        if not is_importable:
+            try:
+                if await self.dispatcher.trigger_logic_repair(
+                    file_path, current_error, write
+                ):
+                    modified = True
+            except Exception as e:
+                errors.append(f"Failed logic repair: {e}")
+
+        # 3. THE BOOKING
+        if modified and write:
+            try:
+                await update_system_memory(file_path, write=write)
+            except Exception as e:
+                errors.append(f"Failed to update system memory: {e}")
+
+        # 4. THE RECORD
+        final_ok = modified and not errors
+        await record_action_result(
+            file_path=file_path,
+            ok=final_ok,
+            duration_ms=int((time.time() - start_time) * 1000),
+            error_message="; ".join(errors) if errors else None,
+            action_metadata={
+                "violations_found": len(file_violations),
+                "violations_fixed": modified,
+                "write_mode": write,
+                "errors": errors,
+            },
+        )
+
+        return {
+            "status": "healed" if final_ok else "failed",
+            "file": file_path,
+            "write_applied": write and modified,
+            "errors": errors,
+        }

will/self_healing/audit_remediation_service.py

@@ -0,0 +1,199 @@
+# src/will/self_healing/audit_remediation_service.py
+"""Audit Remediation Service - The A2 Autonomy Bridge.
+
+Orchestrates the full remediation cycle:
+    Audit Findings → Pattern Matching → Fix Execution → Validation → Evidence
+
+Constitutional alignment:
+- All writes via FileHandler (IntentGuard enforcement)
+- Validation mandatory (must prove improvement)
+- Evidence artifacts required (full traceability)
+- Mind-Body-Will separation maintained
+
+V2.7 FIX:
+- _default_findings_path() now uses PathResolver.audit_findings_processed_path.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+from body.self_healing.remediation_models import (
+    RemediationMode,
+    RemediationResult,
+    create_remediation_result,
+)
+from body.services.file_service import FileService
+from mind.governance.audit_context import AuditorContext
+from shared.logger import getLogger
+from shared.models import AuditFinding, AuditSeverity
+from shared.path_resolver import PathResolver
+from will.self_healing.remediation_evidence_writer import RemediationEvidenceWriter
+from will.self_healing.remediation_executor import RemediationExecutor
+from will.self_healing.remediation_pattern_matcher import RemediationPatternMatcher
+
+
+logger = getLogger(__name__)
+
+
+# ID: f3720fdc-1ad0-416a-b35f-c682a50b3e17
+class AuditRemediationService:
+    """Constitutional bridge between audit findings and autonomous remediation.
+
+    Delegates to three focused collaborators:
+    - RemediationPatternMatcher: finding → pattern resolution
+    - RemediationExecutor: handler dispatch and execution
+    - RemediationEvidenceWriter: validation audit and artifact persistence
+    """
+
+    def __init__(
+        self,
+        file_handler: FileService,
+        auditor_context: AuditorContext,
+        repo_root: Path,
+    ) -> None:
+        self.repo_root = repo_root
+        self._path_resolver = PathResolver(repo_root)
+        self._matcher = RemediationPatternMatcher()
+        self._executor = RemediationExecutor(file_handler, repo_root)
+        self._evidence = RemediationEvidenceWriter(
+            file_handler, auditor_context, repo_root
+        )
+
+        logger.info(
+            "AuditRemediationService initialized with %d fix patterns",
+            len(self._matcher.patterns),
+        )
+
+    # ID: 7b88ca76-5300-40b4-90e9-4b7b52f33f98
+    async def remediate(
+        self,
+        findings_path: Path | None = None,
+        mode: RemediationMode = RemediationMode.SAFE_ONLY,
+        target_pattern: str | None = None,
+        write: bool = False,
+    ) -> RemediationResult:
+        """Execute the complete remediation cycle.
+
+        Args:
+            findings_path: Path to audit findings JSON (defaults to PathResolver).
+            mode: Risk tolerance for automatic fixes.
+            target_pattern: If provided, only fix this pattern (e.g., "style.*").
+            write: If False, dry-run mode (no actual changes).
+
+        Returns:
+            RemediationResult with complete evidence trail.
+        """
+        start_time = time.time()
+        logger.info(
+            "Starting remediation: mode=%s, write=%s, target=%s",
+            mode.value,
+            write,
+            target_pattern or "all",
+        )
+
+        findings = await self._load_findings(findings_path)
+        logger.info("Loaded %d audit findings", len(findings))
+
+        matched, unmatched = self._matcher.match(findings, mode, target_pattern)
+        logger.info(
+            "Pattern matching: %d matched, %d unmatched", len(matched), len(unmatched)
+        )
+
+        fix_details = await self._executor.execute(matched, write)
+        logger.info("Fix execution complete: %d attempts", len(fix_details))
+
+        if write and any(d.status == "success" for d in fix_details):
+            (
+                validation_passed,
+                findings_after,
+                validation_path,
+            ) = await self._evidence.validate_improvement(len(findings))
+        else:
+            validation_passed, findings_after, validation_path = (
+                False,
+                len(findings),
+                None,
+            )
+
+        result = create_remediation_result(
+            total_findings=len(findings),
+            findings_by_severity=self._evidence.count_by_severity(findings),
+            matched_patterns=matched,
+            unmatched_findings=unmatched,
+            fix_details=fix_details,
+            findings_before=len(findings),
+            findings_after=findings_after,
+            audit_input_path=str(findings_path or self._default_findings_path()),
+            remediation_output_path="",
+            validation_audit_path=str(validation_path) if validation_path else None,
+            duration_sec=time.time() - start_time,
+        )
+
+        evidence_path = await self._evidence.write_evidence(result)
+        result.remediation_output_path = str(evidence_path)
+
+        logger.info(
+            "Remediation complete: %d/%d successful, improvement=%d, validation=%s",
+            result.fixes_succeeded,
+            result.fixes_attempted,
+            result.improvement_delta,
+            "PASSED" if result.validation_passed else "FAILED",
+        )
+        return result
+
+    # ID: e8a9b0c1-d2e3-4567-efab-888888888888
+    def _default_findings_path(self) -> Path:
+        """Return the canonical processed findings path via PathResolver."""
+        return self._path_resolver.audit_findings_processed_path
+
+    # ID: f9b0c1d2-e3f4-5678-fabc-999999999999
+    async def _load_findings(self, findings_path: Path | None) -> list[AuditFinding]:
+        """Load audit findings from JSON file."""
+        path = findings_path or self._default_findings_path()
+
+        if not path.exists():
+            logger.warning(
+                "Audit findings file not found: %s — returning empty list.", path
+            )
+            return []
+
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError) as e:
+            logger.error("Failed to load audit findings from %s: %s", path, e)
+            return []
+
+        if not isinstance(raw, list):
+            logger.error(
+                "Unexpected findings format in %s: expected list, got %s",
+                path,
+                type(raw),
+            )
+            return []
+
+        findings = []
+        for item in raw:
+            if not isinstance(item, dict):
+                continue
+            try:
+                severity_str = item.get("severity", "high").lower()
+                severity_map = {str(s): s for s in AuditSeverity}
+                severity = severity_map.get(severity_str, AuditSeverity.HIGH)
+
+                findings.append(
+                    AuditFinding(
+                        check_id=item.get("check_id", item.get("rule_id", "")),
+                        severity=severity,
+                        message=item.get("message", ""),
+                        file_path=item.get("file_path"),
+                        line_number=item.get("line_number"),
+                    )
+                )
+            except Exception as e:
+                logger.warning("Skipping malformed finding: %s — %s", item, e)
+
+        logger.info("Loaded %d valid findings from %s", len(findings), path)
+        return findings