core-runtime 0.1.1__py3-none-any.whl

will/autonomy/proposal_mapper.py

@@ -0,0 +1,187 @@
+# src/will/autonomy/proposal_mapper.py
+
+"""
+Proposal Mapper - Domain/Database Model Conversion
+
+CONSTITUTIONAL ALIGNMENT:
+- Single Responsibility: Convert between Proposal and AutonomousProposal
+- Stateless utility class
+- No database access
+
+Extracted from ProposalRepository to separate data transformation concerns.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from shared.workers.base import _sanitize_payload
+from will.autonomy.proposal import Proposal
+
+
+# ID: 8d7c9f1e-2a4b-5c6d-7e8f-9a0b1c2d3e4f
+class ProposalMapper:
+    """Converts between Proposal domain model and AutonomousProposal database model."""
+
+    @staticmethod
+    # ID: f1e2d3c4-b5a6-7890-abcd-ef1234567890
+    def to_db_model(proposal: Proposal, db_class: type) -> Any:
+        """
+        Convert domain Proposal to database AutonomousProposal.
+
+        Args:
+            proposal: Domain model
+            db_class: AutonomousProposal class (passed to avoid import)
+
+        Returns:
+            Database model instance
+        """
+        return db_class(
+            proposal_id=proposal.proposal_id,
+            goal=proposal.goal,
+            status=proposal.status.value,
+            actions=[
+                {
+                    "action_id": a.action_id,
+                    "flow_id": a.flow_id,
+                    "parameters": a.parameters,
+                    "order": a.order,
+                }
+                for a in proposal.actions
+            ],
+            scope={
+                "files": proposal.scope.files,
+                "modules": proposal.scope.modules,
+                "symbols": proposal.scope.symbols,
+                "policies": proposal.scope.policies,
+            },
+            risk=(
+                {
+                    "overall_risk": proposal.risk.overall_risk,
+                    "action_risks": proposal.risk.action_risks,
+                    "risk_factors": proposal.risk.risk_factors,
+                    "mitigation": proposal.risk.mitigation,
+                }
+                if proposal.risk
+                else None
+            ),
+            created_at=proposal.created_at,
+            created_by=proposal.created_by,
+            # ADR-032+/#274 (#291): every JSONB write on this path runs
+            # through _sanitize_payload — the parent fix 830cc798 covered
+            # only execution_results; validation_checks / validation_results
+            # / constitutional_constraints carry the same SQL_ASCII risk
+            # because audit messages routinely contain em-dashes.
+            validation_checks=_sanitize_payload(proposal.validation_checks),
+            validation_results=_sanitize_payload(proposal.validation_results),
+            execution_started_at=proposal.execution_started_at,
+            execution_completed_at=proposal.execution_completed_at,
+            execution_results=_sanitize_payload(proposal.execution_results),
+            constitutional_constraints=_sanitize_payload(
+                proposal.constitutional_constraints
+            ),
+            approval_required=proposal.approval_required,
+            approved_by=proposal.approved_by,
+            approved_at=proposal.approved_at,
+            approval_authority=proposal.approval_authority,
+            failure_reason=proposal.failure_reason,
+        )
+
+    @staticmethod
+    # ID: e997a6e0-0a79-4cc9-aabf-04d39c8639b7
+    def from_db_model(db_proposal: Any) -> Proposal:
+        """
+        Convert database AutonomousProposal to domain Proposal.
+
+        Args:
+            db_proposal: Database model instance
+
+        Returns:
+            Domain model
+        """
+        data = {
+            "proposal_id": db_proposal.proposal_id,
+            "goal": db_proposal.goal,
+            "actions": db_proposal.actions,
+            "scope": db_proposal.scope,
+            "risk": db_proposal.risk,
+            "status": db_proposal.status,
+            "created_at": db_proposal.created_at.isoformat(),
+            "created_by": db_proposal.created_by,
+            "validation_checks": db_proposal.validation_checks,
+            "validation_results": db_proposal.validation_results,
+            "execution_started_at": (
+                db_proposal.execution_started_at.isoformat()
+                if db_proposal.execution_started_at
+                else None
+            ),
+            "execution_completed_at": (
+                db_proposal.execution_completed_at.isoformat()
+                if db_proposal.execution_completed_at
+                else None
+            ),
+            "execution_results": db_proposal.execution_results,
+            "constitutional_constraints": db_proposal.constitutional_constraints,
+            "approval_required": db_proposal.approval_required,
+            "approved_by": db_proposal.approved_by,
+            "approved_at": (
+                db_proposal.approved_at.isoformat() if db_proposal.approved_at else None
+            ),
+            "approval_authority": db_proposal.approval_authority,
+            "failure_reason": db_proposal.failure_reason,
+        }
+        return Proposal.from_dict(data)
+
+    @staticmethod
+    # ID: 12c03c5a-fc4a-42d7-a906-48c824c56189
+    def update_db_model(db_proposal: Any, proposal: Proposal) -> None:
+        """
+        Update database model fields from domain model.
+
+        Args:
+            db_proposal: Database model to update (mutated in place)
+            proposal: Source domain model
+        """
+        db_proposal.goal = proposal.goal
+        db_proposal.status = proposal.status.value
+        db_proposal.actions = [
+            {
+                "action_id": a.action_id,
+                "flow_id": a.flow_id,
+                "parameters": a.parameters,
+                "order": a.order,
+            }
+            for a in proposal.actions
+        ]
+        db_proposal.scope = {
+            "files": proposal.scope.files,
+            "modules": proposal.scope.modules,
+            "symbols": proposal.scope.symbols,
+            "policies": proposal.scope.policies,
+        }
+        db_proposal.risk = (
+            {
+                "overall_risk": proposal.risk.overall_risk,
+                "action_risks": proposal.risk.action_risks,
+                "risk_factors": proposal.risk.risk_factors,
+                "mitigation": proposal.risk.mitigation,
+            }
+            if proposal.risk
+            else None
+        )
+        # ADR-032+/#274 (#291): mirror to_db_model — every JSONB write on
+        # this UPDATE path runs through _sanitize_payload so session.flush()
+        # can't carry non-ASCII into SQL_ASCII JSONB.
+        db_proposal.validation_checks = _sanitize_payload(proposal.validation_checks)
+        db_proposal.validation_results = _sanitize_payload(proposal.validation_results)
+        db_proposal.execution_started_at = proposal.execution_started_at
+        db_proposal.execution_completed_at = proposal.execution_completed_at
+        db_proposal.execution_results = _sanitize_payload(proposal.execution_results)
+        db_proposal.constitutional_constraints = _sanitize_payload(
+            proposal.constitutional_constraints
+        )
+        db_proposal.approval_required = proposal.approval_required
+        db_proposal.approved_by = proposal.approved_by
+        db_proposal.approved_at = proposal.approved_at
+        db_proposal.approval_authority = proposal.approval_authority
+        db_proposal.failure_reason = proposal.failure_reason

will/autonomy/proposal_repository.py

@@ -0,0 +1,118 @@
+# src/will/autonomy/proposal_repository.py
+
+"""
+Proposal Repository - Pure Persistence for A3 Proposals.
+
+CONSTITUTIONAL FIX (V2.3):
+- Modularized to reduce Modularity Debt (51.3 -> ~40.0).
+- Stripped of state machine logic (delegated to ProposalStateManager).
+- Stripped of mapping logic (delegated to ProposalMapper).
+- Aligns with the Octopus-UNIX Synthesis: Pure Persistence capability.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import select
+
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+from will.autonomy.proposal import Proposal, ProposalStatus
+from will.autonomy.proposal_mapper import ProposalMapper
+
+
+logger = getLogger(__name__)
+
+_CFG_PR = load_operational_config().proposals
+
+
+# ID: 265ff56b-f1a1-45ba-853b-fd4c97d54f72
+class ProposalRepository:
+    """
+    Handles pure CRUD operations for autonomous proposals.
+
+    This is a 'Body' component of the Will layer: it executes
+    database instructions but contains no strategic logic.
+    """
+
+    def __init__(self, session: Any):
+        """
+        Initialize with an active database session.
+
+        Constitutional Note: Callers should use the 'open()' context manager
+        provided by the service registry.
+        """
+        self._session = session
+
+    # ID: f8b8727b-7e4d-4d32-a6cb-475cac9551f7
+    async def get(self, proposal_id: str) -> Proposal | None:
+        """Retrieves a domain Proposal by its public ID string."""
+        from shared.infrastructure.database.models.autonomous_proposals import (
+            AutonomousProposal,
+        )
+
+        stmt = select(AutonomousProposal).where(
+            AutonomousProposal.proposal_id == proposal_id
+        )
+        result = await self._session.execute(stmt)
+        db_record = result.scalar_one_or_none()
+
+        if not db_record:
+            return None
+
+        return ProposalMapper.from_db_model(db_record)
+
+    # ID: 3848ee7d-8eac-4835-abeb-7ea378ae15a5
+    async def create(self, proposal: Proposal) -> str:
+        """Persists a new proposal record."""
+        from shared.infrastructure.database.models.autonomous_proposals import (
+            AutonomousProposal,
+        )
+
+        db_model = ProposalMapper.to_db_model(proposal, AutonomousProposal)
+        self._session.add(db_model)
+        # Flush to get the ID but leave commit to the workflow orchestrator
+        await self._session.flush()
+
+        logger.debug("Persisted proposal record: %s", proposal.proposal_id)
+        return proposal.proposal_id
+
+    # ID: 190fdc4c-77e9-4d99-986b-7c3a0d302560
+    async def list_by_status(
+        self, status: ProposalStatus, limit: int = _CFG_PR.list_limit
+    ) -> list[Proposal]:
+        """Queries the database for proposals in a specific lifecycle state."""
+        from shared.infrastructure.database.models.autonomous_proposals import (
+            AutonomousProposal,
+        )
+
+        stmt = (
+            select(AutonomousProposal)
+            .where(AutonomousProposal.status == status.value)
+            .order_by(AutonomousProposal.created_at.desc())
+            .limit(limit)
+            .with_for_update(skip_locked=True)
+        )
+        result = await self._session.execute(stmt)
+        return [ProposalMapper.from_db_model(p) for p in result.scalars().all()]
+
+    # ID: 23d0dc09-c889-41f3-8f11-284e0a894660
+    async def update_fields(self, proposal_id: str, updates: dict[str, Any]) -> None:
+        """
+        Atomic field update.
+        Used by StateManager to advance the lifecycle without re-mapping the whole object.
+        """
+        from sqlalchemy import update
+
+        from shared.infrastructure.database.models.autonomous_proposals import (
+            AutonomousProposal,
+        )
+
+        stmt = (
+            update(AutonomousProposal)
+            .where(AutonomousProposal.proposal_id == proposal_id)
+            .values(**updates)
+        )
+        await self._session.execute(stmt)
+        # We do not commit here; the Will layer orchestrator manages the transaction.

will/autonomy/proposal_service.py

@@ -0,0 +1,251 @@
+# src/will/autonomy/proposal_service.py
+
+"""
+Proposal Service - High-Level Facade
+
+CONSTITUTIONAL ALIGNMENT:
+- Facade Pattern: Simplifies common workflows
+- Coordinates Repository + StateManager
+- Provides convenience methods for callers
+
+This is the primary entry point for proposal operations.
+Use this instead of accessing Repository/StateManager directly.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from sqlalchemy import text
+
+from body.services.service_registry import service_registry
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+from will.autonomy.proposal import Proposal, ProposalScope, ProposalStatus
+from will.autonomy.proposal_repository import ProposalRepository
+from will.autonomy.proposal_state_manager import ProposalStateManager
+
+
+logger = getLogger(__name__)
+
+_CFG_PR = load_operational_config().proposals
+
+
+# ID: 1f2e3d4c-5b6a-7890-1234-567890abcdef
+class ProposalService:
+    """
+    High-level service for proposal operations.
+
+    Coordinates CRUD (repository) and state management (state manager).
+
+    Usage:
+        async with ProposalService.open() as service:
+            proposal = await service.get("id")
+            await service.mark_completed("id", results)
+    """
+
+    def __init__(self, session: Any):
+        self._session = session
+        self._repository = ProposalRepository(session)
+        self._state_manager = ProposalStateManager(session)
+
+    @classmethod
+    @asynccontextmanager
+    # ID: 1c11271b-7170-4a70-93d3-25afeb7701c6
+    async def open(cls) -> AsyncIterator[ProposalService]:
+        """Open service with managed session."""
+        async with service_registry.session() as session:
+            yield cls(session)
+
+    # -------------------------
+    # CRUD Operations (delegate to repository)
+    # -------------------------
+
+    # ID: 4b27f951-a174-4623-ba8b-6ca021b74e5e
+    async def create(self, proposal: Proposal) -> str:
+        """Create new proposal."""
+        return await self._repository.create(proposal)
+
+    # ID: 6ffa51f0-c7bd-4ea8-bd18-5cd79c76b6f1
+    async def get(self, proposal_id: str) -> Proposal | None:
+        """Get proposal by ID."""
+        return await self._repository.get(proposal_id)
+
+    # ID: a576c452-efd2-466a-a296-44af1bbd0015
+    async def update(self, proposal: Proposal) -> None:
+        """Update proposal."""
+        await self._repository.update(proposal)
+
+    # ID: 03c9360e-4bae-4a75-b208-8fe1c0c1d58b
+    async def list_by_status(
+        self, status: ProposalStatus, limit: int = _CFG_PR.list_limit
+    ) -> list[Proposal]:
+        """List proposals by status."""
+        return await self._repository.list_by_status(status, limit)
+
+    # ID: f046639e-4ca6-4d4c-9068-e5d27bdd9857
+    async def list_pending_approval(
+        self, limit: int = _CFG_PR.pending_limit
+    ) -> list[Proposal]:
+        """List proposals awaiting approval (status == PENDING)."""
+        return await self._repository.list_by_status(ProposalStatus.PENDING, limit)
+
+    # -------------------------
+    # State Transitions (delegate to state manager)
+    # -------------------------
+
+    # ID: bc89da1a-1a65-4982-8e45-1e85d5bea7c6
+    async def mark_completed(self, proposal_id: str, results: dict[str, Any]) -> None:
+        """Mark proposal as completed."""
+        await self._state_manager.mark_completed(proposal_id, results)
+
+    # ID: c30a8f14-0c38-4c1b-b42b-675d5e498ca7
+    async def mark_failed(self, proposal_id: str, reason: str) -> None:
+        """Mark proposal as failed."""
+        await self._state_manager.mark_failed(proposal_id, reason)
+
+    # ID: b2d228b9-fe0a-436a-9fec-1d4f590e337e
+    async def approve(
+        self,
+        proposal_id: str,
+        approved_by: str,
+        approval_authority: str,
+    ) -> None:
+        """Approve proposal.
+
+        approval_authority is non-omittable per URS NFR.5; forwarded to
+        ProposalStateManager.approve which validates against the
+        proposal_approval_authority closed set.
+
+        Commits the session after the state-manager call, since
+        ProposalStateManager.approve no longer commits internally.
+        """
+        await self._state_manager.approve(proposal_id, approved_by, approval_authority)
+        await self._session.commit()
+
+    # ID: ca316432-a09e-4af3-9a63-82a39b08ebb2
+    async def reject(self, proposal_id: str, reason: str) -> int:
+        """Reject proposal and revive deferred findings (ADR-010 §7a).
+
+        Returns revived_count (0 if no findings were deferred).
+        """
+        await self._state_manager.reject(proposal_id, reason)
+        bb_service = await service_registry.get_blackboard_service()
+        revival = await bb_service.revive_findings_for_failed_proposal(
+            proposal_id=proposal_id,
+            failure_reason=f"rejected: {reason}",
+        )
+        return revival["revived_count"] if revival else 0
+
+    # -------------------------
+    # Convenience Methods
+    # -------------------------
+
+    # ID: bdd4ca3b-32e5-46ae-bf1b-c3b1cbb96776
+    async def get_or_fail(self, proposal_id: str) -> Proposal:
+        """
+        Get proposal or raise error if not found.
+
+        Raises:
+            ValueError: If proposal doesn't exist
+        """
+        proposal = await self.get(proposal_id)
+        if not proposal:
+            raise ValueError(f"Proposal not found: {proposal_id}")
+        return proposal
+
+    # -------------------------
+    # Blast Radius / Scope
+    # -------------------------
+
+    # ID: 3e4f5a6b-7c8d-9e0f-1a2b-3c4d5e6f7a8b
+    async def populate_scope_from_blast_radius(
+        self,
+        proposal: Proposal,
+        target_symbol_paths: list[str],
+    ) -> ProposalScope:
+        """
+        Query v_symbol_blast_radius for the given symbols and return a
+        fully-populated ProposalScope.
+
+        The scope aggregates across all target symbols:
+          - symbols: the target symbols themselves + all transitively affected symbols
+          - files:   all distinct file_paths in the blast radius
+          - modules: all distinct module dotted paths in the blast radius
+
+        Args:
+            proposal: The proposal being built (not mutated here — caller assigns scope).
+            target_symbol_paths: List of symbol_path values to analyse
+                                 (e.g. ["src/will/autonomy/proposal_service.py::ProposalService.create"])
+
+        Returns:
+            A ProposalScope populated from the blast radius data.
+        """
+        if not target_symbol_paths:
+            logger.warning(
+                "populate_scope_from_blast_radius called with empty target list "
+                "for proposal '%s'",
+                getattr(proposal, "proposal_id", "?"),
+            )
+            return ProposalScope()
+
+        result = await self._session.execute(
+            text(
+                """
+                SELECT
+                    v.symbol_path,
+                    v.file_path,
+                    v.module,
+                    v.affected_files,
+                    v.affected_modules,
+                    v.affected_symbol_count
+                FROM core.v_symbol_blast_radius v
+                WHERE v.symbol_path = ANY(:paths)
+                """
+            ),
+            {"paths": list(target_symbol_paths)},
+        )
+        rows = result.fetchall()
+
+        if not rows:
+            logger.warning(
+                "populate_scope_from_blast_radius: none of %d target symbol(s) "
+                "found in v_symbol_blast_radius",
+                len(target_symbol_paths),
+            )
+            return ProposalScope(symbols=list(target_symbol_paths))
+
+        all_symbols: set[str] = set(target_symbol_paths)
+        all_files: set[str] = set()
+        all_modules: set[str] = set()
+
+        for row in rows:
+            # Own file and module
+            if row.file_path:
+                all_files.add(row.file_path)
+            if row.module:
+                all_modules.add(row.module)
+
+            # Blast radius aggregates (arrays may be None when no callers exist)
+            for fp in row.affected_files or []:
+                if fp:
+                    all_files.add(fp)
+            for mod in row.affected_modules or []:
+                if mod:
+                    all_modules.add(mod)
+
+        logger.info(
+            "populate_scope_from_blast_radius: %d target(s) → %d file(s), "
+            "%d module(s) in scope",
+            len(rows),
+            len(all_files),
+            len(all_modules),
+        )
+
+        return ProposalScope(
+            symbols=sorted(all_symbols),
+            files=sorted(all_files),
+            modules=sorted(all_modules),
+        )