core-runtime 0.1.1__py3-none-any.whl

body/services/file_service.py

@@ -0,0 +1,260 @@
+# src/body/services/file_service.py
+"""
+Body layer file operations service.
+
+CONSTITUTIONAL COMPLIANCE:
+- Body layer performs file I/O operations
+- Will and API layers delegate file operations here
+- Mind layer must not use this service (law does not execute)
+
+This service provides a controlled interface for file operations,
+ensuring all I/O goes through the Body layer.
+
+CRITICAL FIX: FileHandler methods are write_runtime_text/bytes/json, NOT write_file!
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from shared.infrastructure.storage.file_handler import FileHandler, FileOpResult
+from shared.logger import getLogger
+from shared.path_resolver import PathResolver
+
+
+logger = getLogger(__name__)
+
+
+# ID: 54b51df1-b3c5-4169-9c69-d76b08f77e2b
+class FileService:
+    """
+    Body layer service for file operations.
+
+    Provides controlled I/O operations that Will and API layers can delegate to.
+
+    CONSTITUTIONAL FIX: Extended to wrap all FileHandler operations so Mind/Will
+    never need to import FileHandler directly.
+
+    CRITICAL FIX: Uses correct FileHandler method names (write_runtime_text, not write_file)
+    """
+
+    def __init__(self, repo_path: Path):
+        """
+        Initialize file service.
+
+        Args:
+            repo_path: Repository root path
+        """
+        # Resolve up front so relative_to() against PathResolver-derived paths
+        # (which resolve internally) cannot raise ValueError on symlinked or
+        # otherwise unresolved input. See #270.
+        self.repo_path = Path(repo_path).resolve()
+        self.reports_dir = PathResolver.from_repo(self.repo_path).reports_dir
+
+        # Create FileHandler instance for all operations
+        self._file_handler = FileHandler(str(self.repo_path))
+        logger.debug("FileService initialized for %s", self.repo_path)
+
+    # ========================================================================
+    # EXISTING METHODS (kept for backward compatibility)
+    # ========================================================================
+
+    # ID: 3655aa8f-b18f-46a5-8f0c-45d358155706
+    async def write_report(self, filename: str, content: str) -> Path:
+        """
+        Write a report file to the reports directory.
+        """
+        rel_path = self.reports_dir.relative_to(self.repo_path) / filename
+        self._file_handler.ensure_dir(str(self.reports_dir.relative_to(self.repo_path)))
+        self._file_handler.write_runtime_text(rel_path, content)
+        file_path = self.repo_path / rel_path
+        logger.debug("Wrote report file: %s", file_path)
+        return file_path
+
+    # ID: 50c9ca07-be37-4a7a-9637-6b7904cf550e
+    async def read_report(self, filename: str) -> str:
+        """
+        Read a report file from the reports directory.
+
+        Args:
+            filename: Name of the file to read
+
+        Returns:
+            File content as string
+        """
+        file_path = self.reports_dir / filename
+
+        if not file_path.exists():
+            raise FileNotFoundError(f"Report file not found: {file_path}")
+
+        content = await FileHandler.read_content(file_path)
+        logger.debug("Read report file: %s", file_path)
+        return content
+
+    # ========================================================================
+    # NEW METHODS (wrapping FileHandler correctly)
+    # ========================================================================
+
+    # ID: b1c2d3e4-f5a6-7b8c-9d0e-1f2a3b4c5d6e
+    def write_file(self, rel_path: str, content: str) -> FileOpResult:
+        """
+        Write text content to any repository-relative file.
+
+        CRITICAL FIX: Uses write_runtime_text() which is FileHandler's actual method
+
+        Args:
+            rel_path: Repository-relative path to the target file
+            content: Text content to write
+
+        Returns:
+            FileOpResult with status and message
+        """
+        logger.debug("Writing file: %s", rel_path)
+        # CRITICAL FIX: FileHandler method is write_runtime_text, not write_file
+        result = self._file_handler.write_runtime_text(rel_path, content)
+
+        if result.status == "success":
+            logger.info("Successfully wrote: %s", rel_path)
+        else:
+            logger.error("Failed to write %s: %s", rel_path, result.message)
+
+        return result
+
+    # ID: c2d3e4f5-a6b7-8c9d-0e1f-2a3b4c5d6e7f
+    def write_runtime_bytes(self, rel_path: str, content: bytes) -> FileOpResult:
+        """
+        Write binary content to a runtime/output file.
+
+        Args:
+            rel_path: Repository-relative path
+            content: Binary content to write
+
+        Returns:
+            FileOpResult with status and message
+        """
+        logger.debug("Writing runtime bytes: %s", rel_path)
+        result = self._file_handler.write_runtime_bytes(rel_path, content)
+
+        if result.status == "success":
+            logger.info("Successfully wrote bytes to: %s", rel_path)
+        else:
+            logger.error("Failed to write bytes to %s: %s", rel_path, result.message)
+
+        return result
+
+    # ID: a2b3c4d5-e6f7-8a9b-0c1d-2e3f4a5b6c7d
+    def write_runtime_json(self, rel_path: str, payload: dict) -> FileOpResult:
+        """
+        Write JSON content to a runtime/output file.
+
+        Args:
+            rel_path: Repository-relative path
+            payload: Dictionary to write as JSON
+
+        Returns:
+            FileOpResult with status and message
+        """
+        logger.debug("Writing runtime JSON: %s", rel_path)
+        result = self._file_handler.write_runtime_json(rel_path, payload)
+
+        if result.status == "success":
+            logger.info("Successfully wrote JSON to: %s", rel_path)
+        else:
+            logger.error("Failed to write JSON to %s: %s", rel_path, result.message)
+
+        return result
+
+    # ID: d3e4f5a6-b7c8-9d0e-1f2a-3b4c5d6e7f8a
+    def ensure_dir(self, rel_dir: str) -> FileOpResult:
+        """
+        Ensure a directory exists.
+
+        Args:
+            rel_dir: Repository-relative directory path
+
+        Returns:
+            FileOpResult with status and message
+        """
+        logger.debug("Ensuring directory: %s", rel_dir)
+        result = self._file_handler.ensure_dir(rel_dir)
+
+        if result.status == "success":
+            logger.debug("Directory ready: %s", rel_dir)
+        else:
+            logger.error("Failed to create directory %s: %s", rel_dir, result.message)
+
+        return result
+
+    # ID: e4f5a6b7-c8d9-0e1f-2a3b-4c5d6e7f8a9b
+    def add_pending_write(self, prompt: str, suggested_path: str, code: str) -> str:
+        """
+        Stage a pending write for review.
+
+        Args:
+            prompt: Description of the change
+            suggested_path: Proposed file path
+            code: Content to write
+
+        Returns:
+            Path to the pending write file
+        """
+        logger.debug("Adding pending write: %s", suggested_path)
+        pending_file = self._file_handler.add_pending_write(
+            prompt, suggested_path, code
+        )
+        logger.info("Created pending write: %s", pending_file)
+        return pending_file
+
+    # ID: f5a6b7c8-d9e0-1f2a-3b4c-5d6e7f8a9b0c
+    def read_file(self, rel_path: str) -> str | None:
+        """
+        Read text content from any file.
+
+        Args:
+            rel_path: Repository-relative path
+
+        Returns:
+            File content as string, or None if not found
+        """
+        abs_path = self.repo_path / rel_path
+
+        if not abs_path.exists():
+            logger.warning("File not found: %s", rel_path)
+            return None
+
+        try:
+            content = abs_path.read_text(encoding="utf-8")
+            logger.debug("Read file: %s (%d bytes)", rel_path, len(content))
+            return content
+        except Exception as e:
+            logger.error("Failed to read %s: %s", rel_path, e)
+            return None
+
+    # ID: a6b7c8d9-e0f1-2a3b-4c5d-6e7f8a9b0c1d
+    def file_exists(self, rel_path: str) -> bool:
+        """
+        Check if a file exists.
+
+        Args:
+            rel_path: Repository-relative path
+
+        Returns:
+            True if file exists, False otherwise
+        """
+        abs_path = self.repo_path / rel_path
+        exists = abs_path.exists()
+        logger.debug("File exists check: %s = %s", rel_path, exists)
+        return exists
+
+    # ID: b7c8d9e0-f1a2-3b4c-5d6e-7f8a9b0c1d2e
+    def get_file_handler(self) -> FileHandler:
+        """
+        Get the underlying FileHandler instance.
+
+        WARNING: Escape hatch for advanced use. Prefer FileService methods.
+
+        Returns:
+            FileHandler instance
+        """
+        logger.warning("Direct FileHandler access - prefer FileService methods")
+        return self._file_handler

body/services/governance_claims_service.py

@@ -0,0 +1,240 @@
+# src/body/services/governance_claims_service.py
+"""
+Governance Claims Service - Body Layer
+
+Manages the Qdrant `governance_claims` collection that backs the CCC
+SAMECONCERN and R1_SCOPED checks per ADR-073 D4 / D5.
+
+Responsibilities:
+  - Collection presence check (vector-dependent checks refuse when empty)
+  - Idempotent upsert of harvested Claim objects (incremental contract)
+  - Delete-by-source-path for artifacts removed from the corpus
+  - Search wrapper returning (cosine, payload) tuples for the tiered policy
+
+No settings access; constructor takes a QdrantService via DI.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from qdrant_client.http import models as qm
+
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from shared.governance.coherence_harvester import Claim
+    from shared.infrastructure.clients.qdrant_client import QdrantService
+
+
+logger = getLogger(__name__)
+
+
+GOVERNANCE_CLAIMS_COLLECTION = "governance_claims"
+
+
+@dataclass(frozen=True)
+# ID: 24f7da2c-c76d-4a6a-9620-d92a9b32f835
+class ClaimVector:
+    """A claim paired with its embedding vector, ready for upsert."""
+
+    claim: Claim
+    vector: list[float]
+
+
+@dataclass(frozen=True)
+# ID: 5bc46b63-224d-49d7-81ca-72d0995772bb
+class SearchHit:
+    """One hit from a kNN search against governance_claims."""
+
+    cosine: float
+    source_path: str
+    paragraph_index: int
+    text: str
+    content_sha: str
+    category: str
+
+
+# ID: f1fdd5bd-bfc6-45cc-86a2-745629f17202
+class GovernanceClaimsService:
+    """Qdrant-backed store for governance normative claims."""
+
+    # ID: ee68153e-7367-45e8-853e-bd7250c77708
+    def __init__(self, qdrant: QdrantService, vector_size: int = 768) -> None:
+        self._qdrant = qdrant
+        self._vector_size = vector_size
+
+    @property
+    # ID: d579e0ca-aa2c-41f4-98a2-9ebd0acdb640
+    def collection_name(self) -> str:
+        return GOVERNANCE_CLAIMS_COLLECTION
+
+    # ID: 6ca4d304-c3de-43b6-9888-cfcc072a7f28
+    async def is_seeded(self) -> bool:
+        """Return True iff the collection exists AND has ≥1 point.
+
+        Vector-dependent CCC checks (SAMECONCERN, R1_SCOPED) refuse to emit
+        when this returns False, per ADR-073 D4.
+        """
+        try:
+            collections = await self._qdrant.client.get_collections()
+        except Exception as exc:
+            logger.warning(
+                "governance_claims: failed to list Qdrant collections: %s", exc
+            )
+            return False
+        names = {c.name for c in collections.collections}
+        if self.collection_name not in names:
+            return False
+        try:
+            info = await self._qdrant.client.get_collection(self.collection_name)
+        except Exception as exc:
+            logger.warning("governance_claims: failed to inspect collection: %s", exc)
+            return False
+        return (info.points_count or 0) > 0
+
+    # ID: 496e1f73-60d5-4812-9347-91a078340d8a
+    async def ensure_collection(self) -> None:
+        """Create the collection if absent. Idempotent."""
+        await self._qdrant.ensure_collection(
+            collection_name=self.collection_name,
+            vector_size=self._vector_size,
+        )
+
+    # ID: 681683dd-1bb7-4118-8f31-580cc5433e38
+    async def upsert_claims(self, items: Sequence[ClaimVector]) -> int:
+        """Upsert (point_id, vector, payload) tuples; returns count written.
+
+        Point identity is (source_path, content_sha) — paragraph reordering
+        does not force re-embedding.
+        """
+        if not items:
+            return 0
+        points = [
+            qm.PointStruct(
+                id=_point_id(cv.claim.source_path, cv.claim.content_sha),
+                vector=cv.vector,
+                payload={
+                    "source_path": cv.claim.source_path,
+                    "paragraph_index": cv.claim.paragraph_index,
+                    "line": cv.claim.line,
+                    "text": cv.claim.text,
+                    "category": cv.claim.category,
+                    "content_sha": cv.claim.content_sha,
+                },
+            )
+            for cv in items
+        ]
+        await self._qdrant.upsert_points(self.collection_name, points, wait=True)
+        return len(points)
+
+    # ID: 0b95b690-181b-48de-89bd-719648812305
+    async def delete_by_source_path(self, source_path: str) -> None:
+        """Remove all points belonging to a single source artifact."""
+        await self._qdrant.client.delete(
+            collection_name=self.collection_name,
+            points_selector=qm.FilterSelector(
+                filter=qm.Filter(
+                    must=[
+                        qm.FieldCondition(
+                            key="source_path",
+                            match=qm.MatchValue(value=source_path),
+                        )
+                    ]
+                )
+            ),
+            wait=True,
+        )
+
+    # ID: 1fd1324e-7b1c-4bf3-914c-c5faf22a2354
+    async def current_keys(self) -> set[tuple[str, str]]:
+        """Return {(source_path, content_sha)} for every point in the collection.
+
+        The set is the canonical "what's already embedded" view used by the
+        sync worker to compute the incremental diff in O(corpus + collection).
+        Identity is content-keyed, so paragraph reordering within a file does
+        not force re-embedding.
+        """
+        records = await self._qdrant.scroll_all_points(
+            with_payload=True,
+            with_vectors=False,
+            page_size=1024,
+            collection_name=self.collection_name,
+        )
+        result: set[tuple[str, str]] = set()
+        for record in records:
+            payload = record.payload or {}
+            source_path = payload.get("source_path")
+            content_sha = payload.get("content_sha")
+            if isinstance(source_path, str) and isinstance(content_sha, str):
+                result.add((source_path, content_sha))
+        return result
+
+    # ID: 04a0c52c-6a14-469a-a85b-19b0c978c3d5
+    async def delete_by_keys(self, keys: Sequence[tuple[str, str]]) -> int:
+        """Delete points by (source_path, content_sha). Returns count."""
+        if not keys:
+            return 0
+        point_ids = [_point_id(path, sha) for path, sha in keys]
+        await self._qdrant.client.delete(
+            collection_name=self.collection_name,
+            points_selector=qm.PointIdsList(points=point_ids),
+            wait=True,
+        )
+        return len(point_ids)
+
+    # ID: 644e1d97-0c04-4788-8523-79707f59db45
+    async def search(
+        self,
+        query_vector: list[float],
+        limit: int = 10,
+        score_threshold: float | None = None,
+        source_path_in: list[str] | None = None,
+    ) -> list[SearchHit]:
+        """kNN search returning enriched hits for the tiered-cosine policy (D5).
+
+        `source_path_in`, when set, restricts hits to claims from the listed
+        artifacts — used by R1_SCOPED (D2) to bound search to declared
+        `Relates:` pairs.
+        """
+        query_filter = None
+        if source_path_in:
+            query_filter = qm.Filter(
+                must=[
+                    qm.FieldCondition(
+                        key="source_path",
+                        match=qm.MatchAny(any=source_path_in),
+                    )
+                ]
+            )
+        scored = await self._qdrant.search(
+            collection_name=self.collection_name,
+            query_vector=query_vector,
+            limit=limit,
+            score_threshold=score_threshold,
+            query_filter=query_filter,
+        )
+        hits: list[SearchHit] = []
+        for s in scored:
+            payload = s.payload or {}
+            hits.append(
+                SearchHit(
+                    cosine=float(s.score),
+                    source_path=str(payload.get("source_path", "")),
+                    paragraph_index=int(payload.get("paragraph_index", 0)),
+                    text=str(payload.get("text", "")),
+                    content_sha=str(payload.get("content_sha", "")),
+                    category=str(payload.get("category", "")),
+                )
+            )
+        return hits
+
+
+def _point_id(source_path: str, content_sha: str) -> str:
+    """Deterministic UUID5 from (source_path, content_sha)."""
+    import uuid
+
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, f"{source_path}::{content_sha}"))

body/services/governance_init.py

@@ -0,0 +1,41 @@
+# src/body/services/governance_init.py
+
+"""
+Governance Integration Service for Application Startup.
+
+Provides initialization utilities for constitutional governance system.
+Used during FastAPI lifespan or CLI startup to load and validate constitution.
+"""
+
+from __future__ import annotations
+
+from body.services.constitutional_validator import get_validator
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: 47d49349-577d-4c8a-864f-4037f2c1b026
+def initialize_governance():
+    """
+    Initialize constitutional governance system.
+
+    Call this during FastAPI lifespan startup to load and validate
+    the constitution.
+
+    Returns:
+        ConstitutionalValidator instance
+    """
+    logger.info("📜 Loading constitutional governance...")
+    try:
+        validator = get_validator()
+        logger.info("✅ Constitutional governance ready")
+        logger.info("   📊 Indexed: %s critical paths", len(validator._critical_paths))
+        logger.info(
+            "   📊 Indexed: %s autonomous actions", len(validator._autonomous_actions)
+        )
+        return validator
+    except Exception as e:
+        logger.error("❌ Failed to load constitution: %s", e)
+        raise