core-runtime 0.1.1__py3-none-any.whl

body/services/health_log_service.py

@@ -0,0 +1,167 @@
+# src/body/services/health_log_service.py
+"""
+HealthLogService - Data-access layer for system state reads and
+core.system_health_log writes.
+
+Covers:
+  - ObserverWorker._collect_state (all four count queries)
+  - ObserverWorker._write_health_log
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import text
+
+from body.services.worker_registry_service import WorkerRegistryService
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+from shared.workers.schedule import load_worker_schedule_state
+
+
+logger = getLogger(__name__)
+
+_CFG = load_operational_config().health_log
+
+
+# ID: 1c26b39c-f6d2-4bee-a65c-bb24071ea25c
+class HealthLogService:
+    """
+    Body layer service. Exposes system-state reads across
+    core.blackboard_entries, core.worker_registry, and core.symbols,
+    plus a write to core.system_health_log.
+    All four read queries share a single session to match the
+    original ObserverWorker._collect_state() semantics.
+    """
+
+    # ID: 1661aae5-c77e-4094-b057-4de80858bba9
+    async def collect_system_state(
+        self, stale_threshold_seconds: int = _CFG.stale_threshold_seconds
+    ) -> dict[str, Any]:
+        """
+        Run all four system-state count queries in one session and return
+        a state dict with keys: open_findings, stale_entries,
+        silent_workers, orphaned_symbols.
+
+        Covers:
+          - ObserverWorker._collect_state
+          - ObserverWorker._count_open_findings
+          - ObserverWorker._count_stale_entries
+          - ObserverWorker._count_silent_workers
+          - ObserverWorker._count_orphaned_symbols
+        """
+        from datetime import UTC, datetime
+
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            # Exclusion list, not inclusion: open_findings counts everything
+            # that is NOT terminal/parked. 'awaiting_reaudit' (ADR-045) is
+            # intentionally absent from the exclusion list — those rows
+            # represent unresolved work awaiting sensor adjudication, and
+            # should remain visible in the trajectory.
+            r = await session.execute(
+                text(
+                    """
+                    SELECT COUNT(*) FROM core.blackboard_entries
+                    WHERE entry_type = 'finding'
+                      AND status NOT IN (
+                          'resolved',
+                          'abandoned',
+                          'suppressed',
+                          'dry_run_complete',
+                          'deferred_to_proposal',
+                          'indeterminate'
+                      )
+                    """
+                )
+            )
+            open_findings: int = r.scalar() or 0
+
+            r = await session.execute(
+                text(
+                    """
+                    SELECT COUNT(*) FROM core.blackboard_entries
+                    WHERE status NOT IN (
+                          'resolved',
+                          'abandoned',
+                          'suppressed',
+                          'dry_run_complete',
+                          'deferred_to_proposal',
+                          'indeterminate'
+                      )
+                      AND created_at < now() - make_interval(secs => :threshold)
+                    """
+                ),
+                {"threshold": stale_threshold_seconds},
+            )
+            stale_entries: int = r.scalar() or 0
+
+            # silent_workers per ADR-041 D2/D3: per-worker thresholds from
+            # the shared schedule loader, plus orphan-skip. Same canonical
+            # rule WorkerShopManager and the runtime dashboard apply.
+            schedule_state = load_worker_schedule_state()
+            registry_svc = WorkerRegistryService()
+            silent_rows = await registry_svc.fetch_stale_workers_with_schedules(
+                thresholds=schedule_state.thresholds,
+                active_uuids=schedule_state.active_uuids,
+                fallback_sec=schedule_state.fallback_sec,
+            )
+            silent_workers: int = len(silent_rows)
+
+            r = await session.execute(
+                text(
+                    """
+                    SELECT COUNT(*) FROM core.symbols s1
+                    WHERE s1.key IS NULL
+                        AND s1.is_public = true
+                        AND NOT EXISTS (
+                        -- Check if any other symbol's 'calls' array contains this symbol's qualname
+                        SELECT 1 FROM core.symbols s2
+                        WHERE s2.calls @> to_jsonb(s1.qualname)
+                        )
+                    """
+                )
+            )
+            orphaned_symbols: int = r.scalar() or 0
+
+        return {
+            "open_findings": open_findings,
+            "stale_entries": stale_entries,
+            "silent_workers": silent_workers,
+            "orphaned_symbols": orphaned_symbols,
+            "observed_at": datetime.now(UTC).isoformat(),
+        }
+
+    # ID: a32e06d3-3c7e-4724-b2b5-47f4b1eb1c92
+    async def write_health_log(self, state: dict[str, Any]) -> None:
+        """
+        Append one row to core.system_health_log. Never updates existing rows.
+
+        Covers:
+          - ObserverWorker._write_health_log
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        async with ServiceRegistry.session() as session:
+            async with session.begin():
+                await session.execute(
+                    text(
+                        """
+                        INSERT INTO core.system_health_log
+                            (open_findings, stale_entries, silent_workers,
+                             orphaned_symbols, payload)
+                        VALUES
+                            (:open_findings, :stale_entries, :silent_workers,
+                             :orphaned_symbols, cast(:payload as jsonb))
+                        """
+                    ),
+                    {
+                        "open_findings": state["open_findings"],
+                        "stale_entries": state["stale_entries"],
+                        "silent_workers": state["silent_workers"],
+                        "orphaned_symbols": state["orphaned_symbols"],
+                        "payload": "{}",
+                    },
+                )

body/services/intent_schema_validator.py

@@ -0,0 +1,211 @@
+# src/body/services/intent_schema_validator.py
+
+"""
+Intent Schema Validator - Constitutional Document Validation
+
+CONSTITUTIONAL ALIGNMENT:
+- Single Responsibility: Validate .intent documents against JSON schemas
+- No CLI dependencies (pure business logic)
+- Reusable across CLI, API, automation
+
+Extracted from cli/logic/validate.py to separate validation logic from presentation.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from jsonschema import ValidationError, validate
+
+from shared.config_loader import load_yaml_file
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+@dataclass
+# ID: a3d80ab0-1305-4aa5-ad7d-e33f55cad6fd
+class SchemaValidationResult:
+    """Result of validating a document against its schema."""
+
+    yaml_path: Path
+    schema_path: Path
+    is_valid: bool
+    error_message: str | None = None
+
+
+@dataclass
+# ID: f90b4c8b-4698-4836-b1aa-056515fd6ca4
+class SchemaPair:
+    """A document paired with its schema."""
+
+    yaml_path: Path
+    schema_path: Path
+
+
+# ID: 8cbe3ca9-3b16-4d69-8608-8b55c422e500
+class IntentSchemaValidator:
+    """
+    Validates .intent YAML documents against their declared JSON schemas.
+
+    Usage:
+        validator = IntentSchemaValidator(Path(".intent"))
+        results = validator.validate_all()
+    """
+
+    def __init__(self, intent_root: Path):
+        """
+        Initialize validator.
+
+        Args:
+            intent_root: Path to .intent directory
+        """
+        self.intent_root = intent_root.resolve()
+        self._exclude_prefixes = ("runtime/", "mind_export/", "keys/")
+
+    # -------------------------
+    # Core Validation Logic
+    # -------------------------
+
+    # ID: 5443f768-20c3-4d05-9a7d-9df34e1b61e0
+    def validate_pair(self, pair: SchemaPair) -> SchemaValidationResult:
+        """
+        Validate a single YAML document against its schema.
+
+        Args:
+            pair: Document and schema pair
+
+        Returns:
+            Validation result
+        """
+        if not pair.yaml_path.exists():
+            return SchemaValidationResult(
+                yaml_path=pair.yaml_path,
+                schema_path=pair.schema_path,
+                is_valid=False,
+                error_message=f"Missing file: {pair.yaml_path}",
+            )
+
+        if not pair.schema_path.exists():
+            return SchemaValidationResult(
+                yaml_path=pair.yaml_path,
+                schema_path=pair.schema_path,
+                is_valid=False,
+                error_message=f"Missing schema: {pair.schema_path}",
+            )
+
+        try:
+            data = load_yaml_file(pair.yaml_path)
+            schema = self._load_json(pair.schema_path)
+            validate(instance=data, schema=schema)
+
+            return SchemaValidationResult(
+                yaml_path=pair.yaml_path,
+                schema_path=pair.schema_path,
+                is_valid=True,
+            )
+        except ValidationError as e:
+            path = ".".join(map(str, e.path)) or "(root)"
+            return SchemaValidationResult(
+                yaml_path=pair.yaml_path,
+                schema_path=pair.schema_path,
+                is_valid=False,
+                error_message=f"{e.message} at {path}",
+            )
+        except Exception as e:
+            return SchemaValidationResult(
+                yaml_path=pair.yaml_path,
+                schema_path=pair.schema_path,
+                is_valid=False,
+                error_message=f"Unexpected validation error: {e!r}",
+            )
+
+    # ID: 236186ba-1470-4cf7-8efb-ab9db910bb76
+    def validate_all(self) -> tuple[list[SchemaValidationResult], list[str]]:
+        """
+        Validate all .intent documents that declare $schema.
+
+        Returns:
+            (results, skipped_messages)
+        """
+        pairs, skipped = self._discover_schema_pairs()
+        results = [self.validate_pair(pair) for pair in pairs]
+        return results, skipped
+
+    # -------------------------
+    # Discovery Logic
+    # -------------------------
+
+    # ID: 5e6a6d73-f710-48f4-91af-b37a0ca67bd5
+    def _discover_schema_pairs(self) -> tuple[list[SchemaPair], list[str]]:
+        """
+        Discover YAML → JSON-schema pairs using the `$schema` field.
+
+        Returns:
+            (pairs, skipped_messages)
+        """
+        pairs: list[SchemaPair] = []
+        skipped: list[str] = []
+
+        for yaml_path in self._iter_intent_yaml():
+            rel = yaml_path.relative_to(self.intent_root).as_posix()
+
+            try:
+                data = load_yaml_file(yaml_path)
+            except Exception as exc:
+                skipped.append(f"[SKIP] {rel}: YAML parse error: {exc!r}")
+                continue
+
+            if not isinstance(data, dict):
+                skipped.append(f"[SKIP] {rel}: top-level YAML is not a mapping")
+                continue
+
+            schema_ref = data.get("$schema")
+            if not schema_ref:
+                skipped.append(f"[SKIP] {rel}: no $schema field; not validated")
+                continue
+
+            schema_path = (self.intent_root / schema_ref).resolve()
+            pairs.append(SchemaPair(yaml_path=yaml_path, schema_path=schema_path))
+
+        return pairs, skipped
+
+    # ID: 365ba3bf-4559-4300-8536-e88995c9a427
+    def _iter_intent_yaml(self) -> list[Path]:
+        """
+        Return all YAML/YML files under .intent, excluding state folders.
+
+        Returns:
+            Sorted list of YAML file paths
+        """
+        if not self.intent_root.exists():
+            logger.error("Intent root %s does not exist", self.intent_root)
+            return []
+
+        files: list[Path] = []
+        seen: set[Path] = set()
+
+        for pattern in ("**/*.yaml", "**/*.yml"):
+            for path in self.intent_root.glob(pattern):
+                if path in seen:
+                    continue
+                rel = path.relative_to(self.intent_root).as_posix()
+                if any(rel.startswith(prefix) for prefix in self._exclude_prefixes):
+                    continue
+                seen.add(path)
+                files.append(path)
+
+        return sorted(files)
+
+    # -------------------------
+    # Utilities
+    # -------------------------
+
+    @staticmethod
+    def _load_json(path: Path) -> dict:
+        """Load JSON schema from file."""
+        with path.open("r", encoding="utf-8") as f:
+            return json.load(f)

body/services/llm_client.py

@@ -0,0 +1,87 @@
+# src/body/services/llm_client.py
+
+"""
+A dedicated, asynchronous client for interacting with LLM APIs.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: a1cdeb8d-ae98-4891-9b10-c8a571d55443
+class LLMClient:
+    """A wrapper for making asynchronous API calls to a specific LLM."""
+
+    def __init__(
+        self,
+        api_url: str,
+        api_key: str,
+        model_name: str,
+        http_timeout: int | None = None,
+    ):
+        if http_timeout is None:
+            http_timeout = load_operational_config().llm.http_timeout_sec
+        self.api_url = api_url
+        self.api_key = api_key
+        self.model_name = model_name
+        self.http_timeout = http_timeout
+        self.base_url = api_url
+
+    # ID: e2ceb072-9dbd-4379-bc08-28f7b2df3922
+    async def make_request(
+        self,
+        prompt: str,
+        system_prompt: str = "You are a helpful assistant.",
+        max_tokens: int | None = None,
+    ) -> str:
+        """
+        Makes an asynchronous request to the configured LLM API.
+        """
+        if max_tokens is None:
+            max_tokens = load_operational_config().llm.default_max_tokens
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": self.model_name,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt},
+            ],
+            "max_tokens": max_tokens,
+        }
+        async with httpx.AsyncClient(timeout=self.http_timeout) as client:
+            try:
+                logger.debug(
+                    "Making request to %s with model %s", self.api_url, self.model_name
+                )
+                response = await client.post(
+                    self.api_url, headers=headers, json=payload
+                )
+                response.raise_for_status()
+                data = response.json()
+                content = (
+                    data.get("choices", [{}])[0].get("message", {}).get("content", "")
+                )
+                if not content:
+                    logger.warning("LLM response content is empty.")
+                    return ""
+                return content.strip()
+            except httpx.HTTPStatusError as e:
+                logger.error(
+                    "HTTP error occurred: %s - %s",
+                    e.response.status_code,
+                    e.response.text,
+                )
+                raise
+            except Exception as e:
+                logger.error("An unexpected error occurred during LLM request: %s", e)
+                raise

body/services/mind_state_service.py

@@ -0,0 +1,129 @@
+# src/body/services/mind_state_service.py
+
+"""
+MindStateService - Body layer service for accessing Mind state.
+
+Constitutional Compliance:
+- Body layer service: Provides capability without making decisions
+- Mind/Body/Will separation: Encapsulates Mind state access
+- No direct database access in Will: Will gets Mind state through this service
+- Dependency injection: Takes AsyncSession, no global imports
+
+HEALED (V2.3.0):
+- Added detach() to explicitly release DB session references.
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import select
+
+from body.services.session_attached_service import SessionAttachedService
+from shared.infrastructure.config_service import ConfigService
+from shared.infrastructure.database.models import (
+    CognitiveRole,
+    LlmResource,
+    RoleResourceAssignment,
+    SystemConfig,
+)
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+__all__ = ["MindStateService"]
+
+
+# ID: 49fce217-d1fe-480e-8ede-cef3abf4680b
+class MindStateService(SessionAttachedService):
+    """
+    Body service for accessing Mind state (LlmResources, CognitiveRoles, Config).
+    """
+
+    # ID: 7d983b1d-83e8-4b07-86a5-f15b7f4ca981
+    async def get_llm_resources(self) -> list[LlmResource]:
+        """
+        Retrieve available LLM resources from Mind.
+
+        Filters ``is_available=false`` rows at fetch time (#333). The
+        registry says "do not use" for those rows; the router must not
+        see them at all.
+        """
+        session = self._require_session()
+
+        stmt = select(LlmResource).where(LlmResource.is_available == True)  # noqa: E712
+        result = await session.execute(stmt)
+        resources = list(result.scalars().all())
+
+        logger.debug("Retrieved %d LLM resources from Mind", len(resources))
+        return resources
+
+    # ID: be7cff39-76bc-4ba0-a556-5a336f4a9f0c
+    async def get_cognitive_roles(self) -> list[CognitiveRole]:
+        """
+        Retrieve all configured cognitive roles from Mind.
+        """
+        session = self._require_session()
+
+        stmt = select(CognitiveRole)
+        result = await session.execute(stmt)
+        roles = list(result.scalars().all())
+
+        logger.debug("Retrieved %d cognitive roles from Mind", len(roles))
+        return roles
+
+    # ID: 0e0c0b7e-67b9-4dcd-bd3a-9f8c4d51a112
+    async def get_role_resource_assignments(self) -> list[RoleResourceAssignment]:
+        """
+        Retrieve role → resource assignments (ADR-052 Phase 3 replacement
+        for the dropped ``cognitive_roles.assigned_resource`` column).
+
+        Returns every row; callers filter by ``priority`` and
+        ``is_active`` as needed.
+        """
+        session = self._require_session()
+
+        stmt = select(RoleResourceAssignment)
+        result = await session.execute(stmt)
+        assignments = list(result.scalars().all())
+
+        logger.debug(
+            "Retrieved %d role-resource assignments from Mind", len(assignments)
+        )
+        return assignments
+
+    # ID: 0bf49f18-ec35-4ba9-aac0-035a8cd18de3
+    async def get_system_config(self) -> SystemConfig | None:
+        """
+        Retrieve the singleton ``system_config`` row (ADR-052).
+
+        Returns ``None`` if no row exists. Used by callers that need the
+        system-default ``operating_mode`` (#333).
+        """
+        session = self._require_session()
+
+        stmt = select(SystemConfig)
+        result = await session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    # ID: d4e5f678-90ab-cdef-1234-567890abcdef
+    async def get_config_service(self) -> ConfigService:
+        """
+        Create and return a ConfigService instance for configuration access.
+        """
+        session = self._require_session()
+
+        config_service = await ConfigService.create(session)
+        return config_service
+
+    # ID: e5f67890-abcd-ef12-3456-7890abcdef12
+    async def load_mind_state(
+        self,
+    ) -> tuple[list[LlmResource], list[CognitiveRole], ConfigService]:
+        """
+        Load complete Mind state in one call.
+        """
+        resources = await self.get_llm_resources()
+        roles = await self.get_cognitive_roles()
+        config = await self.get_config_service()
+
+        return resources, roles, config