nexus-coding-agent 0.1.0__py3-none-any.whl

nexus/infrastructure/persistence/__init__.py

@@ -0,0 +1,13 @@
+"""SQLAlchemy adapters for Nexus-owned business persistence through Day 3."""
+
+from nexus.infrastructure.persistence.approval_unit_of_work import (
+    SqlAlchemyApprovalUnitOfWorkFactory,
+)
+from nexus.infrastructure.persistence.models import Base
+from nexus.infrastructure.persistence.unit_of_work import SqlAlchemySessionUnitOfWorkFactory
+
+__all__ = [
+    "Base",
+    "SqlAlchemyApprovalUnitOfWorkFactory",
+    "SqlAlchemySessionUnitOfWorkFactory",
+]

nexus/infrastructure/persistence/approval_unit_of_work.py

@@ -0,0 +1,74 @@
+"""Independent async SQLAlchemy transaction boundary for Day 3 approvals."""
+
+from __future__ import annotations
+
+from types import TracebackType
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from nexus.domain.ports.approval_unit_of_work import ApprovalUnitOfWork
+from nexus.domain.ports.repositories import ApprovalRepository, RunRepository, SessionRepository
+from nexus.infrastructure.persistence.repositories import (
+    SqlAlchemyApprovalRepository,
+    SqlAlchemyRunRepository,
+    SqlAlchemySessionRepository,
+)
+
+
+class SqlAlchemyApprovalUnitOfWork:
+    approvals: ApprovalRepository
+    runs: RunRepository
+    sessions: SessionRepository
+
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+        self._session_factory = session_factory
+        self._session: AsyncSession | None = None
+
+    async def __aenter__(self) -> SqlAlchemyApprovalUnitOfWork:
+        if self._session is not None:
+            raise RuntimeError("ApprovalUnitOfWork instances cannot be reused.")
+        session = self._session_factory()
+        try:
+            await session.begin()
+        except Exception:
+            await session.close()
+            raise
+        self._session = session
+        self.approvals = SqlAlchemyApprovalRepository(session)
+        self.runs = SqlAlchemyRunRepository(session)
+        self.sessions = SqlAlchemySessionRepository(session)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        session = self._require_session()
+        try:
+            if exc_type is None:
+                try:
+                    await session.commit()
+                except Exception:
+                    await session.rollback()
+                    raise
+            else:
+                await session.rollback()
+        finally:
+            await session.close()
+            self._session = None
+        return None
+
+    def _require_session(self) -> AsyncSession:
+        if self._session is None:
+            raise RuntimeError("ApprovalUnitOfWork has not been entered.")
+        return self._session
+
+
+class SqlAlchemyApprovalUnitOfWorkFactory:
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+        self._session_factory = session_factory
+
+    def __call__(self) -> ApprovalUnitOfWork:
+        return SqlAlchemyApprovalUnitOfWork(self._session_factory)

nexus/infrastructure/persistence/models.py

@@ -0,0 +1,146 @@
+"""Private SQLAlchemy rows for the business schema through Day 3."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from sqlalchemy import (
+    CheckConstraint,
+    DateTime,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class RepositoryRow(Base):
+    __tablename__ = "repositories"
+
+    id: Mapped[str] = mapped_column(UUID(as_uuid=False), primary_key=True)
+    canonical_path: Mapped[str] = mapped_column(Text, nullable=False, unique=True)
+    metadata_payload: Mapped[dict[str, Any]] = mapped_column(
+        "metadata", JSONB, nullable=False, default=dict
+    )
+    configuration_reference: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+
+
+class SessionRow(Base):
+    __tablename__ = "sessions"
+    __table_args__ = (
+        Index("ix_sessions_repository_last_active", "repository_id", "last_active_at"),
+    )
+
+    session_id: Mapped[str] = mapped_column(UUID(as_uuid=False), primary_key=True)
+    repository_id: Mapped[str] = mapped_column(
+        UUID(as_uuid=False),
+        ForeignKey("repositories.id", ondelete="RESTRICT"),
+        nullable=False,
+    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    last_active_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    configuration_reference: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+
+class RunRow(Base):
+    __tablename__ = "runs"
+    __table_args__ = (
+        CheckConstraint(
+            "status IN ('RUNNING', 'INTERRUPTED', 'COMPLETED', 'FAILED')",
+            name="ck_runs_status_day2",
+        ),
+        Index("ix_runs_session_status_started", "session_id", "status", "started_at"),
+    )
+
+    run_id: Mapped[str] = mapped_column(UUID(as_uuid=False), primary_key=True)
+    session_id: Mapped[str] = mapped_column(
+        UUID(as_uuid=False),
+        ForeignKey("sessions.session_id", ondelete="RESTRICT"),
+        nullable=False,
+    )
+    task: Mapped[str] = mapped_column(Text, nullable=False)
+    status: Mapped[str] = mapped_column(String(32), nullable=False)
+    model_metadata: Mapped[dict[str, Any] | None] = mapped_column(JSONB, nullable=True)
+    started_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    finished_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    token_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    tool_call_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    changed_file_refs: Mapped[list[str] | None] = mapped_column(JSONB, nullable=True)
+    final_outcome: Mapped[dict[str, Any] | None] = mapped_column(JSONB, nullable=True)
+    graph_thread_id: Mapped[str] = mapped_column(Text, nullable=False, unique=True)
+
+
+class SessionTurnRow(Base):
+    __tablename__ = "session_turns"
+    __table_args__ = (
+        UniqueConstraint("session_id", "sequence", name="uq_session_turns_session_sequence"),
+    )
+
+    id: Mapped[str] = mapped_column(UUID(as_uuid=False), primary_key=True)
+    session_id: Mapped[str] = mapped_column(
+        UUID(as_uuid=False),
+        ForeignKey("sessions.session_id", ondelete="RESTRICT"),
+        nullable=False,
+    )
+    run_id: Mapped[str | None] = mapped_column(
+        UUID(as_uuid=False),
+        ForeignKey("runs.run_id", ondelete="RESTRICT"),
+        nullable=True,
+    )
+    sequence: Mapped[int] = mapped_column(Integer, nullable=False)
+    role: Mapped[str] = mapped_column(Text, nullable=False)
+    content: Mapped[str] = mapped_column(Text, nullable=False)
+    metadata_payload: Mapped[dict[str, Any] | None] = mapped_column(
+        "metadata", JSONB, nullable=True
+    )
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+
+
+class ApprovalRow(Base):
+    __tablename__ = "approvals"
+    __table_args__ = (
+        CheckConstraint(
+            "risk_level IN ('SAFE', 'WRITE', 'DANGEROUS')",
+            name="ck_approvals_risk_level_day3",
+        ),
+        CheckConstraint(
+            "decision IN ('PENDING', 'APPROVED', 'DENIED')",
+            name="ck_approvals_decision_day3",
+        ),
+        CheckConstraint(
+            "(decision = 'PENDING' AND decided_at IS NULL) OR "
+            "(decision IN ('APPROVED', 'DENIED') AND decided_at IS NOT NULL)",
+            name="ck_approvals_decided_at_day3",
+        ),
+        Index("ix_approvals_run_created", "run_id", "created_at", "approval_id"),
+    )
+
+    approval_id: Mapped[str] = mapped_column(UUID(as_uuid=False), primary_key=True)
+    run_id: Mapped[str] = mapped_column(
+        UUID(as_uuid=False),
+        ForeignKey("runs.run_id", ondelete="RESTRICT"),
+        nullable=False,
+    )
+    session_id: Mapped[str] = mapped_column(
+        UUID(as_uuid=False),
+        ForeignKey("sessions.session_id", ondelete="RESTRICT"),
+        nullable=False,
+    )
+    operation: Mapped[str] = mapped_column(Text, nullable=False)
+    risk_level: Mapped[str] = mapped_column(String(16), nullable=False)
+    resource_or_command_summary: Mapped[str] = mapped_column(Text, nullable=False)
+    decision: Mapped[str] = mapped_column(String(16), nullable=False)
+    actor: Mapped[str] = mapped_column(Text, nullable=False)
+    reason: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    decided_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)

nexus/infrastructure/persistence/repositories.py

@@ -0,0 +1,326 @@
+"""Async SQLAlchemy implementations of repository ports through Day 3."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from nexus.domain.approvals import ApprovalRequest
+from nexus.domain.persistence import NexusSession, Repository, Run, RunStatus, SessionTurn
+from nexus.domain.tooling import ApprovalDecision, RiskLevel
+from nexus.infrastructure.persistence.models import (
+    ApprovalRow,
+    RepositoryRow,
+    RunRow,
+    SessionRow,
+    SessionTurnRow,
+)
+
+
+class SqlAlchemyApprovalRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def add(self, approval: ApprovalRequest) -> None:
+        self._session.add(_approval_to_row(approval))
+        await self._session.flush()
+
+    async def get(self, approval_id: str) -> ApprovalRequest | None:
+        row = await self._session.get(ApprovalRow, approval_id)
+        return None if row is None else _approval_from_row(row)
+
+    async def list_by_run(self, run_id: str) -> list[ApprovalRequest]:
+        rows = (
+            await self._session.scalars(
+                select(ApprovalRow)
+                .where(ApprovalRow.run_id == run_id)
+                .order_by(ApprovalRow.created_at.asc(), ApprovalRow.approval_id.asc())
+            )
+        ).all()
+        return [_approval_from_row(row) for row in rows]
+
+    async def update(self, approval: ApprovalRequest) -> None:
+        row = await self._session.get(ApprovalRow, approval.approval_id)
+        if row is None:
+            raise LookupError(f"Approval {approval.approval_id} no longer exists.")
+        if row.decision != ApprovalDecision.PENDING.value:
+            raise ValueError("A terminal approval decision cannot be changed.")
+        if approval.decision is ApprovalDecision.PENDING:
+            raise ValueError("Approval update requires a terminal decision.")
+        if (
+            row.run_id != approval.run_id
+            or row.session_id != approval.session_id
+            or row.operation != approval.operation
+            or row.risk_level != approval.risk_level.value
+            or row.resource_or_command_summary != approval.resource_or_command_summary
+            or row.created_at != approval.created_at
+        ):
+            raise ValueError("Immutable approval fields cannot be changed.")
+        row.decision = approval.decision.value
+        row.actor = approval.actor
+        row.reason = approval.reason
+        row.decided_at = approval.decided_at
+        await self._session.flush()
+
+
+class SqlAlchemyRepositoryRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def add(self, repository: Repository) -> None:
+        self._session.add(_repository_to_row(repository))
+        await self._session.flush()
+
+    async def get(self, repository_id: str) -> Repository | None:
+        row = await self._session.get(RepositoryRow, repository_id)
+        return None if row is None else _repository_from_row(row)
+
+    async def get_by_canonical_path(self, canonical_path: str) -> Repository | None:
+        row = await self._session.scalar(
+            select(RepositoryRow).where(RepositoryRow.canonical_path == canonical_path)
+        )
+        return None if row is None else _repository_from_row(row)
+
+
+class SqlAlchemySessionRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def add(self, session: NexusSession) -> None:
+        self._session.add(_session_to_row(session))
+        await self._session.flush()
+
+    async def get(self, session_id: str) -> NexusSession | None:
+        row = await self._session.get(SessionRow, session_id)
+        return None if row is None else _session_from_row(row)
+
+    async def list_by_repository(self, repository_id: str) -> list[NexusSession]:
+        rows = (
+            await self._session.scalars(
+                select(SessionRow)
+                .where(SessionRow.repository_id == repository_id)
+                .order_by(SessionRow.last_active_at.desc(), SessionRow.session_id.asc())
+            )
+        ).all()
+        return [_session_from_row(row) for row in rows]
+
+    async def update(self, session: NexusSession) -> None:
+        row = await self._session.get(SessionRow, session.session_id)
+        if row is None:
+            raise LookupError(f"Session {session.session_id} no longer exists.")
+        row.repository_id = session.repository_id
+        row.created_at = session.created_at
+        row.last_active_at = session.last_active_at
+        row.configuration_reference = session.configuration_reference
+        await self._session.flush()
+
+
+class SqlAlchemyRunRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def add(self, run: Run) -> None:
+        self._session.add(_run_to_row(run))
+        await self._session.flush()
+
+    async def get(self, run_id: str) -> Run | None:
+        row = await self._session.get(RunRow, run_id)
+        return None if row is None else _run_from_row(row)
+
+    async def get_latest_interrupted(self, session_id: str) -> Run | None:
+        row = await self._session.scalar(
+            select(RunRow)
+            .where(
+                RunRow.session_id == session_id,
+                RunRow.status == RunStatus.INTERRUPTED.value,
+            )
+            .order_by(RunRow.started_at.desc(), RunRow.run_id.desc())
+            .limit(1)
+        )
+        return None if row is None else _run_from_row(row)
+
+    async def has_interrupted(self, session_id: str) -> bool:
+        result = await self._session.scalar(
+            select(RunRow.run_id)
+            .where(
+                RunRow.session_id == session_id,
+                RunRow.status == RunStatus.INTERRUPTED.value,
+            )
+            .limit(1)
+        )
+        return result is not None
+
+    async def update(self, run: Run) -> None:
+        row = await self._session.get(RunRow, run.run_id)
+        if row is None:
+            raise LookupError(f"Run {run.run_id} no longer exists.")
+        _apply_run(row, run)
+        await self._session.flush()
+
+
+class SqlAlchemySessionTurnRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def add(self, turn: SessionTurn) -> None:
+        self._session.add(_turn_to_row(turn))
+        await self._session.flush()
+
+    async def list_by_session(self, session_id: str) -> list[SessionTurn]:
+        rows = (
+            await self._session.scalars(
+                select(SessionTurnRow)
+                .where(SessionTurnRow.session_id == session_id)
+                .order_by(SessionTurnRow.sequence.asc())
+            )
+        ).all()
+        return [_turn_from_row(row) for row in rows]
+
+    async def next_sequence(self, session_id: str) -> int:
+        current = await self._session.scalar(
+            select(func.max(SessionTurnRow.sequence)).where(
+                SessionTurnRow.session_id == session_id
+            )
+        )
+        return 1 if current is None else int(current) + 1
+
+
+def _repository_to_row(entity: Repository) -> RepositoryRow:
+    return RepositoryRow(
+        id=entity.repository_id,
+        canonical_path=entity.canonical_path,
+        metadata_payload=entity.metadata,
+        configuration_reference=entity.configuration_reference,
+        created_at=entity.created_at,
+    )
+
+
+def _repository_from_row(row: RepositoryRow) -> Repository:
+    return Repository(
+        repository_id=row.id,
+        canonical_path=row.canonical_path,
+        metadata=dict(row.metadata_payload),
+        configuration_reference=row.configuration_reference,
+        created_at=row.created_at,
+    )
+
+
+def _session_to_row(entity: NexusSession) -> SessionRow:
+    return SessionRow(
+        session_id=entity.session_id,
+        repository_id=entity.repository_id,
+        created_at=entity.created_at,
+        last_active_at=entity.last_active_at,
+        configuration_reference=entity.configuration_reference,
+    )
+
+
+def _session_from_row(row: SessionRow) -> NexusSession:
+    return NexusSession(
+        session_id=row.session_id,
+        repository_id=row.repository_id,
+        created_at=row.created_at,
+        last_active_at=row.last_active_at,
+        configuration_reference=row.configuration_reference,
+    )
+
+
+def _run_to_row(entity: Run) -> RunRow:
+    row = RunRow(run_id=entity.run_id)
+    _apply_run(row, entity)
+    return row
+
+
+def _apply_run(row: RunRow, entity: Run) -> None:
+    row.session_id = entity.session_id
+    row.task = entity.task
+    row.status = entity.status.value
+    row.model_metadata = entity.model_metadata
+    row.started_at = entity.started_at
+    row.finished_at = entity.finished_at
+    row.token_count = entity.token_count
+    row.tool_call_count = entity.tool_call_count
+    row.changed_file_refs = entity.changed_file_refs
+    row.final_outcome = entity.final_outcome
+    row.graph_thread_id = entity.graph_thread_id
+
+
+def _run_from_row(row: RunRow) -> Run:
+    return Run(
+        run_id=row.run_id,
+        session_id=row.session_id,
+        task=row.task,
+        status=RunStatus(row.status),
+        model_metadata=_optional_dict(row.model_metadata),
+        started_at=row.started_at,
+        finished_at=row.finished_at,
+        token_count=row.token_count,
+        tool_call_count=row.tool_call_count,
+        changed_file_refs=None if row.changed_file_refs is None else list(row.changed_file_refs),
+        final_outcome=_optional_dict(row.final_outcome),
+        graph_thread_id=row.graph_thread_id,
+    )
+
+
+def _turn_to_row(entity: SessionTurn) -> SessionTurnRow:
+    return SessionTurnRow(
+        id=entity.id,
+        session_id=entity.session_id,
+        run_id=entity.run_id,
+        sequence=entity.sequence,
+        role=entity.role,
+        content=entity.content,
+        metadata_payload=entity.metadata,
+        created_at=entity.created_at,
+    )
+
+
+def _turn_from_row(row: SessionTurnRow) -> SessionTurn:
+    return SessionTurn(
+        id=row.id,
+        session_id=row.session_id,
+        run_id=row.run_id,
+        sequence=row.sequence,
+        role=row.role,
+        content=row.content,
+        metadata=_optional_dict(row.metadata_payload),
+        created_at=row.created_at,
+    )
+
+
+def _optional_dict(value: dict[str, Any] | None) -> dict[str, object] | None:
+    return None if value is None else dict(value)
+
+
+def _approval_to_row(entity: ApprovalRequest) -> ApprovalRow:
+    return ApprovalRow(
+        approval_id=entity.approval_id,
+        run_id=entity.run_id,
+        session_id=entity.session_id,
+        operation=entity.operation,
+        risk_level=entity.risk_level.value,
+        resource_or_command_summary=entity.resource_or_command_summary,
+        decision=entity.decision.value,
+        actor=entity.actor,
+        reason=entity.reason,
+        created_at=entity.created_at,
+        decided_at=entity.decided_at,
+    )
+
+
+def _approval_from_row(row: ApprovalRow) -> ApprovalRequest:
+    return ApprovalRequest(
+        approval_id=row.approval_id,
+        run_id=row.run_id,
+        session_id=row.session_id,
+        operation=row.operation,
+        risk_level=RiskLevel(row.risk_level),
+        resource_or_command_summary=row.resource_or_command_summary,
+        decision=ApprovalDecision(row.decision),
+        actor=row.actor,
+        reason=row.reason,
+        created_at=row.created_at,
+        decided_at=row.decided_at,
+    )

nexus/infrastructure/persistence/unit_of_work.py

@@ -0,0 +1,82 @@
+"""Concrete async SQLAlchemy transaction boundary for Day 2."""
+
+from __future__ import annotations
+
+from types import TracebackType
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from nexus.domain.ports.repositories import (
+    RepositoryRepository,
+    RunRepository,
+    SessionRepository,
+    SessionTurnRepository,
+)
+from nexus.domain.ports.session_unit_of_work import SessionUnitOfWork
+from nexus.infrastructure.persistence.repositories import (
+    SqlAlchemyRepositoryRepository,
+    SqlAlchemyRunRepository,
+    SqlAlchemySessionRepository,
+    SqlAlchemySessionTurnRepository,
+)
+
+
+class SqlAlchemySessionUnitOfWork:
+    repositories: RepositoryRepository
+    sessions: SessionRepository
+    runs: RunRepository
+    turns: SessionTurnRepository
+
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+        self._session_factory = session_factory
+        self._session: AsyncSession | None = None
+
+    async def __aenter__(self) -> SqlAlchemySessionUnitOfWork:
+        if self._session is not None:
+            raise RuntimeError("SessionUnitOfWork instances cannot be reused.")
+        session = self._session_factory()
+        try:
+            await session.begin()
+        except Exception:
+            await session.close()
+            raise
+        self._session = session
+        self.repositories = SqlAlchemyRepositoryRepository(session)
+        self.sessions = SqlAlchemySessionRepository(session)
+        self.runs = SqlAlchemyRunRepository(session)
+        self.turns = SqlAlchemySessionTurnRepository(session)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        session = self._require_session()
+        try:
+            if exc_type is None:
+                try:
+                    await session.commit()
+                except Exception:
+                    await session.rollback()
+                    raise
+            else:
+                await session.rollback()
+        finally:
+            await session.close()
+            self._session = None
+        return None
+
+    def _require_session(self) -> AsyncSession:
+        if self._session is None:
+            raise RuntimeError("SessionUnitOfWork has not been entered.")
+        return self._session
+
+
+class SqlAlchemySessionUnitOfWorkFactory:
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+        self._session_factory = session_factory
+
+    def __call__(self) -> SessionUnitOfWork:
+        return SqlAlchemySessionUnitOfWork(self._session_factory)