core-runtime 0.1.1__py3-none-any.whl

body/governance/remediation_service.py

@@ -0,0 +1,263 @@
+# src/body/governance/remediation_service.py
+"""
+Remediation Service - Body Layer
+
+CONSTITUTIONAL FIX: Execution logic for constitutional remediation
+
+This service performs remediation operations (fixing violations).
+It was split from ConstitutionalMonitor which violated separation by doing
+both orchestration (Will) and execution (Body).
+
+Constitutional Role:
+- Body layer: Pure execution
+- Receives explicit instructions on what to fix
+- No decision-making about when/whether to remediate
+- That's Will layer's responsibility
+
+Migration:
+- OLD: ConstitutionalMonitor (Mind layer) - orchestration + execution (VIOLATION)
+- NEW: RemediationService (Body layer) - execution only (COMPLIANT)
+- NEW: RemediationOrchestrator (Will layer) - orchestration only (COMPLIANT)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.logger import getLogger
+from shared.utils.header_tools import _HeaderTools
+
+
+logger = getLogger(__name__)
+
+
+@dataclass
+# ID: da9e01ed-6964-489d-b516-91d068e5c73e
+class RemediationResult:
+    """Results of a remediation operation."""
+
+    success: bool
+    fixed_count: int
+    failed_count: int
+    error: str | None = None
+
+
+@dataclass
+# ID: 9da005f9-65db-4d26-acf3-2e8b79f5c39f
+class Violation:
+    """Represents a single constitutional violation to be remediated."""
+
+    file_path: str
+    policy_id: str
+    description: str
+    severity: str
+    remediation_handler: str | None = None
+
+
+# ID: 8bd6675e-f4e3-4581-90ac-74cdc2caf8a1
+class RemediationService:
+    """
+    Body layer service for constitutional remediation execution.
+
+    CONSTITUTIONAL COMPLIANCE:
+    - Body layer: Executes remediation operations
+    - NO orchestration logic (that's Will's job)
+    - NO decision-making about what/when to fix
+    - Receives explicit instructions and executes them
+
+    This service is given violations and fixes them.
+    It does NOT decide which violations to fix.
+    """
+
+    def __init__(self, repo_path: Path | str):
+        """
+        Initialize remediation service.
+
+        Args:
+            repo_path: Root path of the repository
+        """
+        self.repo_path = Path(repo_path)
+        self.file_handler = FileHandler(str(self.repo_path))
+        logger.info("RemediationService initialized for %s", self.repo_path)
+
+    # ID: f86104cc-4740-4d74-889f-6f622e1d24dc
+    async def remediate_missing_headers(
+        self, violations: list[Violation]
+    ) -> RemediationResult:
+        """
+        Execute remediation for missing header violations.
+
+        BODY LAYER EXECUTION:
+        - Receives list of violations to fix
+        - Does NOT decide which ones to fix (already decided by Will)
+        - Executes the fixes using FileHandler
+        - Reports results
+
+        Args:
+            violations: List of header violations to remediate
+
+        Returns:
+            RemediationResult with counts and status
+        """
+        logger.info("Executing header remediation for %d violations", len(violations))
+
+        fixed_count = 0
+        failed_count = 0
+        error_messages = []
+
+        for violation in violations:
+            try:
+                file_path = Path(violation.file_path)
+
+                # Execute: Read current file
+                if not file_path.exists():
+                    logger.warning("File not found: %s", file_path)
+                    failed_count += 1
+                    continue
+
+                current_content = file_path.read_text(encoding="utf-8")
+
+                # Execute: Add header using HeaderTools
+                updated_content = _HeaderTools.add_header_if_missing(current_content)
+
+                # Execute: Write updated file via FileHandler (constitutional)
+                if updated_content != current_content:
+                    write_result = self.file_handler.write_file(
+                        str(file_path), updated_content
+                    )
+
+                    if write_result.status == "success":
+                        logger.info("Fixed header in: %s", file_path)
+                        fixed_count += 1
+                    else:
+                        logger.error(
+                            "Failed to write %s: %s", file_path, write_result.message
+                        )
+                        failed_count += 1
+                        error_messages.append(f"{file_path}: {write_result.message}")
+                else:
+                    # Header already present, nothing to fix
+                    logger.debug("Header already present in: %s", file_path)
+
+            except Exception as e:
+                logger.error("Error remediating %s: %s", violation.file_path, e)
+                failed_count += 1
+                error_messages.append(f"{violation.file_path}: {e!s}")
+
+        # Report results (no decision-making)
+        success = failed_count == 0
+        error = "; ".join(error_messages) if error_messages else None
+
+        logger.info(
+            "Remediation complete: %d fixed, %d failed", fixed_count, failed_count
+        )
+
+        return RemediationResult(
+            success=success,
+            fixed_count=fixed_count,
+            failed_count=failed_count,
+            error=error,
+        )
+
+    # ID: 7d18bb42-18a0-4834-8334-be92a27f36a8
+    async def remediate_single_file(self, file_path: str) -> bool:
+        """
+        Execute remediation for a single file.
+
+        BODY LAYER EXECUTION:
+        - Receives explicit file path to fix
+        - Does NOT decide whether to fix it (already decided)
+        - Executes the fix
+        - Reports success/failure
+
+        Args:
+            file_path: Path to file that needs remediation
+
+        Returns:
+            True if remediation succeeded, False otherwise
+        """
+        try:
+            path = Path(file_path)
+
+            if not path.exists():
+                logger.warning("File not found: %s", file_path)
+                return False
+
+            # Execute: Read file
+            current_content = path.read_text(encoding="utf-8")
+
+            # Execute: Add header
+            updated_content = _HeaderTools.add_header_if_missing(current_content)
+
+            # Execute: Write if changed
+            if updated_content != current_content:
+                write_result = self.file_handler.write_file(file_path, updated_content)
+
+                if write_result.status == "success":
+                    logger.info("Fixed header in: %s", file_path)
+                    return True
+                else:
+                    logger.error(
+                        "Failed to write %s: %s", file_path, write_result.message
+                    )
+                    return False
+            else:
+                # Already has header
+                logger.debug("Header already present in: %s", file_path)
+                return True
+
+        except Exception as e:
+            logger.error("Error remediating %s: %s", file_path, e)
+            return False
+
+    # ID: 0a08a917-26cb-41ea-9711-3e1335e07ed3
+    def validate_remediation(self, file_path: str) -> bool:
+        """
+        Validate that remediation was successful for a file.
+
+        BODY LAYER EXECUTION:
+        - Checks if file now has proper header
+        - Pure verification, no decision-making
+
+        Args:
+            file_path: Path to file to validate
+
+        Returns:
+            True if file has proper header, False otherwise
+        """
+        try:
+            path = Path(file_path)
+
+            if not path.exists():
+                return False
+
+            content = path.read_text(encoding="utf-8")
+            return _HeaderTools.has_valid_header(content)
+
+        except Exception as e:
+            logger.error("Error validating %s: %s", file_path, e)
+            return False
+
+
+# ID: aa015db1-8ed4-4017-86d9-19f1be437214
+def get_remediation_service(repo_path: Path | str | None = None) -> RemediationService:
+    """
+    Factory function for remediation service.
+
+    Args:
+        repo_path: Optional repository path (defaults to current directory)
+
+    Returns:
+        RemediationService instance
+
+    Usage:
+        # Body layer: Execute remediation
+        service = get_remediation_service()
+        result = await service.remediate_missing_headers(violations)
+    """
+    if repo_path is None:
+        repo_path = Path.cwd()
+
+    return RemediationService(repo_path)

body/governance/runtime_validator.py

@@ -0,0 +1,184 @@
+# src/body/governance/runtime_validator.py
+
+"""
+Runtime Validator - Body Layer Execution Service.
+
+Provides the "Canary Sandbox" capability to run the project's test suite
+against proposed code changes in a safe, isolated environment.
+
+CONSTITUTIONAL ALIGNMENT (V2.3.0):
+- Relocated: Moved from Mind to Body to resolve architecture.mind.no_body_invocation.
+- Responsibility: Execution of sandboxed tests (Body capability).
+- The Airlock: Subprocesses run with a SANITIZED environment to prevent
+  leakage or corruption of production infrastructure.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+from body.services.file_service import FileService
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+from shared.path_resolver import PathResolver
+
+
+logger = getLogger(__name__)
+
+_CFG = load_operational_config().testing
+
+
+# ID: 282dad34-9366-49a0-91dd-c889a7d6f8da
+class RuntimeValidatorService:
+    """
+    A service to test code changes in an isolated environment (Canary).
+
+    CONSTITUTIONAL COMPLIANCE:
+    - Resides in Body layer (Execution).
+    - Uses FileService for all file operations.
+    - Enforces Environment Isolation (The Airlock).
+    """
+
+    def __init__(
+        self,
+        path_resolver: PathResolver,
+        test_timeout: int = _CFG.runtime_validator_timeout_sec,
+    ):
+        self._paths = path_resolver
+        self.repo_root = self._paths.repo_root
+        self.test_timeout = test_timeout
+
+    # ID: 3615c13a-c101-4bca-9a10-7bb72604e13b
+    async def run_tests_in_canary(
+        self, file_path_str: str, new_code_content: str
+    ) -> tuple[bool, str]:
+        """
+        Creates a temporary copy of the project, applies the new code, and runs pytest.
+        Uses a SANITIZED environment to prevent side effects on the host system.
+
+        Returns:
+            A tuple of (passed: bool, details: str).
+        """
+        # Use a tmpdir for isolation.
+        # CLAUDE.md /tmp/ prohibition: temp dir must resolve inside the repo under var/tmp/.
+        with tempfile.TemporaryDirectory(
+            prefix="core_canary_", dir=str(self.repo_root / "var" / "tmp")
+        ) as tmpdir:
+            canary_path = Path(tmpdir) / "canary_repo"
+            logger.info("Creating canary test environment at %s...", canary_path)
+
+            try:
+                # 1. Initialize FileService rooted at the canary repo
+                fs = FileService(canary_path)
+
+                # 2. Replicate the Body (Code)
+                fs.ensure_dir(".")
+                _copy_repo_tree(
+                    src_root=self.repo_root,
+                    file_service=fs,
+                    ignore_names={
+                        ".git",
+                        self._paths.intent_root.name,  # Don't copy .intent/
+                        ".venv",
+                        "venv",
+                        "__pycache__",
+                        ".pytest_cache",
+                        ".ruff_cache",
+                        "work",
+                        ".env",  # DANGER: Do not copy .env
+                        ".env.test",  # DANGER: Do not copy .env.test
+                    },
+                )
+
+                # 3. Apply the Candidate Code
+                rel_target = Path(file_path_str).as_posix().lstrip("./")
+                # Use get_file_handler() escape hatch to write the proposed code
+                file_handler = fs.get_file_handler()
+                file_handler.write_runtime_text(rel_target, new_code_content)
+
+                # 4. Construct "The Airlock" (Sanitized Environment)
+                safe_env = os.environ.copy()
+
+                # Nuke keys to prevent sandbox leakage
+                for unsafe in [
+                    "DATABASE_URL",
+                    "LLM_API_KEY",
+                    "CORE_MASTER_KEY",
+                    "QDRANT_URL",
+                    "QDRANT_API_KEY",
+                ]:
+                    if unsafe in safe_env:
+                        del safe_env[unsafe]
+
+                # Inject Safe Defaults (Force Unit Test Mode)
+                safe_env["DATABASE_URL"] = "sqlite+aiosqlite:///:memory:"
+                safe_env["CORE_ENV"] = "TEST"
+                safe_env["LLM_ENABLED"] = "false"
+                safe_env["PYTHONPATH"] = str(canary_path)
+
+                logger.info("Running test suite in AIRLOCKED canary environment...")
+
+                # 5. Execute
+                proc = await asyncio.create_subprocess_exec(
+                    "poetry",
+                    "run",
+                    "pytest",
+                    cwd=canary_path,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    env=safe_env,
+                )
+
+                try:
+                    stdout, stderr = await asyncio.wait_for(
+                        proc.communicate(), timeout=self.test_timeout
+                    )
+                except TimeoutError:
+                    proc.kill()
+                    logger.error("Canary tests timed out.")
+                    return (
+                        False,
+                        f"Tests timed out after {self.test_timeout} seconds.",
+                    )
+
+                if proc.returncode == 0:
+                    logger.info("✅ Canary tests PASSED.")
+                    return (True, "All tests passed in the isolated environment.")
+
+                logger.warning("❌ Canary tests FAILED.")
+                error_details = (
+                    f"Pytest failed with exit code {proc.returncode}.\n\n"
+                    f"STDOUT:\n{stdout.decode(errors='replace')}\n\n"
+                    f"STDERR:\n{stderr.decode(errors='replace')}"
+                )
+                return (False, error_details)
+
+            except Exception as e:
+                logger.error("Error during canary test run: %s", e, exc_info=True)
+                return (False, f"An unexpected exception occurred: {e!s}")
+
+
+def _copy_repo_tree(
+    src_root: Path, file_service: FileService, ignore_names: set[str]
+) -> None:
+    """
+    Copy a repository tree via governed writes.
+    """
+    src_root = Path(src_root).resolve()
+    # Walk the tree
+    for src_path in src_root.rglob("*"):
+        rel_parts = src_path.relative_to(src_root).parts
+        if any(part in ignore_names for part in rel_parts):
+            continue
+
+        rel = src_path.relative_to(src_root).as_posix()
+
+        if src_path.is_dir():
+            file_service.ensure_dir(rel)
+            continue
+
+        if src_path.is_file():
+            file_service.write_runtime_bytes(rel, src_path.read_bytes())

body/infrastructure/bootstrap.py

@@ -0,0 +1,135 @@
+# src/body/infrastructure/bootstrap.py
+
+"""
+System Bootstrap - CoreContext Initialization
+
+CONSTITUTIONAL EXEMPTION:
+This module is the 'Ignition Point'. It IS the infrastructure layer.
+It MUST import 'settings' directly to wire the Dependency Injection container.
+Once CoreContext is created here, all other layers receive configuration
+via DI, complying with the constitution.
+"""
+
+from __future__ import annotations
+
+from body.atomic.executor import ActionExecutor
+from shared.config import settings
+from shared.context import CoreContext
+from shared.infrastructure.context.service import ContextService
+from shared.infrastructure.database.session_manager import get_session
+from shared.infrastructure.git_service import GitService
+from shared.infrastructure.knowledge.knowledge_service import KnowledgeService
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.models import PlannerConfig
+from shared.path_resolver import PathResolver
+
+
+def _build_context_service() -> ContextService:
+    """
+    Factory for ContextService.
+
+    CONSTITUTIONAL FIX:
+    We no longer instantiate QdrantService or CognitiveService here.
+    Instead, we pass None, and the ContextService (updated in Step 9)
+     will pull the initialized versions from the registry JIT.
+    """
+    from body.services.service_registry import service_registry
+
+    return ContextService(
+        project_root=str(settings.REPO_PATH),
+        session_factory=service_registry.session,
+        qdrant_client=None,
+        cognitive_service=None,
+        brain_services_provider=service_registry,
+    )
+
+
+def _build_context_builder_factory(core_context: CoreContext):
+    """
+    Factory-of-factories for ArchitecturalContextBuilder. ADR-025.
+
+    Returns a zero-arg closure that, when called by CoreContext.context_builder,
+    reads cognitive_service and qdrant_service from the supplied core_context
+    and assembles a fully-wired ArchitecturalContextBuilder. Both services
+    must be populated on core_context by the time the closure is invoked
+    (the daemon lifespan does this; CLI commands that need Priority 1 mode
+    must do the same). Missing deps surface as a non-RuntimeError exception
+    so action_build_tests' JIT-fallback can catch and proceed with None.
+    """
+
+    def _factory():
+        from will.tools.architectural_context_builder import (
+            ArchitecturalContextBuilder,
+        )
+        from will.tools.module_anchor_generator import ModuleAnchorGenerator
+        from will.tools.policy_vectorizer import PolicyVectorizer
+
+        cognitive = core_context.cognitive_service
+        qdrant = core_context.qdrant_service
+        if cognitive is None or qdrant is None:
+            raise ValueError(
+                "context_builder factory requires cognitive_service and "
+                "qdrant_service to be populated on CoreContext; got "
+                f"cognitive_service={cognitive!r}, qdrant_service={qdrant!r}",
+            )
+
+        repo_root = settings.REPO_PATH
+        builder_path_resolver = PathResolver.from_repo(
+            repo_root=repo_root,
+            intent_root=settings.MIND,
+        )
+        return ArchitecturalContextBuilder(
+            policy_vectorizer=PolicyVectorizer(repo_root, cognitive, qdrant),
+            anchor_generator=ModuleAnchorGenerator(repo_root, cognitive, qdrant),
+            path_resolver=builder_path_resolver,
+            session_factory=core_context.registry.session,
+            cognitive_service=cognitive,
+            qdrant_service=qdrant,
+        )
+
+    return _factory
+
+
+# ID: 140caea1-4d7b-4b80-ad31-80d0d2dc2a90
+def create_core_context(service_registry) -> CoreContext:
+    """
+    Bootstrap CoreContext and prime the ServiceRegistry.
+    """
+    # 1. Prime the registry with the database primitive
+    service_registry.prime(get_session)
+
+    # 2. Configure infrastructure connections
+    service_registry.configure(
+        repo_path=settings.REPO_PATH,
+        qdrant_url=settings.QDRANT_URL,
+        qdrant_collection_name=settings.QDRANT_COLLECTION_NAME,
+    )
+
+    repo_path = settings.REPO_PATH
+
+    # 3. Create PathResolver (The Map)
+    path_resolver = PathResolver.from_repo(
+        repo_root=repo_path,
+        intent_root=settings.MIND,
+    )
+
+    # 4. Build the Context object
+    core_context = CoreContext(
+        registry=service_registry,
+        settings=settings,
+        git_service=GitService(repo_path),
+        file_handler=FileHandler(str(repo_path)),
+        planner_config=PlannerConfig(),
+        knowledge_service=KnowledgeService(repo_path),
+    )
+
+    # 5. Attach Resolver and Executor
+    core_context.path_resolver = path_resolver
+    core_context.action_executor = ActionExecutor(core_context)
+
+    # 6. Attach the factories
+    core_context.context_service_factory = _build_context_service
+    # ADR-025
+    core_context.context_builder_factory = _build_context_builder_factory(core_context)
+
+    return core_context

body/infrastructure/lifespan.py

@@ -0,0 +1,85 @@
+# src/body/infrastructure/lifespan.py
+
+"""
+System Lifespan - Infrastructure Ignition Sequence.
+
+CONSTITUTIONAL FIX (P2.3):
+Moved from shared.infrastructure to body.infrastructure to prevent
+the shared layer from importing higher-level Body/Mind components.
+"""
+
+from __future__ import annotations
+
+import os
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING
+
+from body.infrastructure.bootstrap import create_core_context
+from body.services.service_registry import service_registry
+from shared.config import settings
+from shared.infrastructure.config_service import ConfigService
+from shared.infrastructure.diagnostic_service import DiagnosticService
+from shared.logger import getLogger, reconfigure_log_level
+
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+logger = getLogger(__name__)
+
+
+@asynccontextmanager
+# ID: 174c23d1-ad9d-4785-bbde-0f1bf408f180
+async def core_lifespan(app: FastAPI):
+    """
+    Constitutional ignition and shutdown sequence for the CORE system.
+    """
+    logger.info("🚀 Starting CORE system...")
+
+    # 1. CONSTITUTIONAL BOOTSTRAP
+    core_context = create_core_context(service_registry)
+    app.state.core_context = core_context
+
+    if os.getenv("PYTEST_CURRENT_TEST"):
+        core_context._is_test_mode = True
+
+    try:
+        if not getattr(core_context, "_is_test_mode", False):
+            # 2. PRE-IGNITION SENSATION (Health Gate)
+            diagnostic = DiagnosticService(settings.REPO_PATH)
+            health = await diagnostic.check_connectivity()
+
+            unhealthy_components = [
+                name for name, res in health.items() if not res["ok"]
+            ]
+
+            if unhealthy_components:
+                msg = f"Degraded Infrastructure Detected: {', '.join(unhealthy_components)}"
+                if settings.CORE_STRICT_MODE:
+                    logger.critical("❌ STRICT MODE: Aborting startup. %s", msg)
+                    raise RuntimeError(f"Constitutional Ignition Failure: {msg}")
+                else:
+                    logger.warning("⚠️ ADVISORY MODE: Continuing despite %s", msg)
+
+            # 3. WARM UP HEAVY SERVICES
+            cognitive = await service_registry.get_cognitive_service()
+            auditor = await service_registry.get_auditor_context()
+            qdrant = await service_registry.get_qdrant_service()
+
+            core_context.cognitive_service = cognitive
+            core_context.auditor_context = auditor
+            core_context.qdrant_service = qdrant
+
+            # 4. DATABASE & CONFIG INITIALIZATION
+            async with service_registry.session() as session:
+                config = await ConfigService.create(session)
+                log_level_from_db = await config.get("LOG_LEVEL", "INFO")
+                reconfigure_log_level(log_level_from_db)
+                await cognitive.initialize(session)
+
+            # 5. LOAD KNOWLEDGE GRAPH
+            await auditor.load_knowledge_graph()
+
+        yield
+    finally:
+        logger.info("🛑 CORE system shutting down.")

body/infrastructure/repositories/__init__.py

@@ -0,0 +1 @@
+# src/body/infrastructure/repositories/__init__.py