draft-board 0.1.0-beta.0

package/app/backend/app/models/ticket.py

@@ -0,0 +1,223 @@
+"""Ticket model for Draft."""
+
+import json
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+from app.state_machine import TicketState
+
+if TYPE_CHECKING:
+    from app.models.agent_session import AgentSession
+    from app.models.board import Board
+    from app.models.evidence import Evidence
+    from app.models.goal import Goal
+    from app.models.job import Job
+    from app.models.revision import Revision
+    from app.models.ticket_event import TicketEvent
+    from app.models.workspace import Workspace
+
+
+class Ticket(Base):
+    """Ticket model representing a unit of work.
+
+    IMPORTANT: Tickets are scoped by board_id for permission enforcement.
+    The board_id should match the goal's board_id.
+
+    BLOCKING/DEPENDENCIES:
+    - blocked_by_ticket_id: If set, this ticket is blocked by another ticket
+    - A ticket cannot be queued for execution until its blocker is DONE
+    - When generating tickets, the agent can specify dependencies
+    """
+
+    __tablename__ = "tickets"
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    board_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("boards.id", ondelete="CASCADE"),
+        nullable=True,  # Nullable for migration compatibility
+        index=True,
+    )
+    goal_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("goals.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    title: Mapped[str] = mapped_column(String(255), nullable=False)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+    state: Mapped[str] = mapped_column(
+        String(50),
+        default=TicketState.PROPOSED.value,
+        nullable=False,
+        index=True,
+    )
+    priority: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    sort_order: Mapped[int | None] = mapped_column(
+        Integer,
+        nullable=True,
+        index=True,
+        doc="Manual sort order within a state column (lower = higher position)",
+    )
+    verification_commands_json: Mapped[str | None] = mapped_column(
+        Text, nullable=True, doc="JSON array of verification commands"
+    )
+    # Blocking/dependency: If set, this ticket cannot be executed until the blocker is DONE
+    blocked_by_ticket_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("tickets.id", ondelete="SET NULL"),
+        nullable=True,
+        index=True,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    # GitHub Pull Request fields
+    pr_number: Mapped[int | None] = mapped_column(Integer, nullable=True, index=True)
+    pr_url: Mapped[str | None] = mapped_column(String(500), nullable=True)
+    pr_state: Mapped[str | None] = mapped_column(
+        String(20), nullable=True
+    )  # 'OPEN', 'CLOSED', 'MERGED'
+    pr_created_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    pr_merged_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    pr_head_branch: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    pr_base_branch: Mapped[str | None] = mapped_column(String(255), nullable=True)
+
+    # Relationships
+    board: Mapped["Board | None"] = relationship("Board", back_populates="tickets")
+    goal: Mapped["Goal"] = relationship("Goal", back_populates="tickets")
+    events: Mapped[list["TicketEvent"]] = relationship(
+        "TicketEvent",
+        back_populates="ticket",
+        cascade="all, delete-orphan",
+        order_by="TicketEvent.created_at",
+    )
+    jobs: Mapped[list["Job"]] = relationship(
+        "Job",
+        back_populates="ticket",
+        cascade="all, delete-orphan",
+        order_by="Job.created_at.desc()",
+    )
+    workspace: Mapped["Workspace | None"] = relationship(
+        "Workspace",
+        back_populates="ticket",
+        cascade="all, delete-orphan",
+        uselist=False,
+    )
+    evidence: Mapped[list["Evidence"]] = relationship(
+        "Evidence",
+        back_populates="ticket",
+        cascade="all, delete-orphan",
+        order_by="Evidence.created_at.desc()",
+    )
+    revisions: Mapped[list["Revision"]] = relationship(
+        "Revision",
+        back_populates="ticket",
+        cascade="all, delete-orphan",
+        order_by="Revision.number.desc()",
+    )
+    agent_sessions: Mapped[list["AgentSession"]] = relationship(
+        "AgentSession",
+        back_populates="ticket",
+        cascade="all, delete-orphan",
+        order_by="AgentSession.created_at.desc()",
+    )
+
+    # Blocking relationship (self-referential)
+    blocked_by: Mapped["Ticket | None"] = relationship(
+        "Ticket",
+        foreign_keys=[blocked_by_ticket_id],
+        remote_side="Ticket.id",
+        uselist=False,
+        back_populates="blocking",
+    )
+    # Tickets that this ticket is blocking
+    blocking: Mapped[list["Ticket"]] = relationship(
+        "Ticket",
+        foreign_keys="Ticket.blocked_by_ticket_id",
+        back_populates="blocked_by",
+    )
+
+    @property
+    def state_enum(self) -> TicketState:
+        """Get the state as a TicketState enum."""
+        return TicketState(self.state)
+
+    @property
+    def is_blocked_by_dependency(self) -> bool:
+        """Check if this ticket is blocked by an incomplete dependency.
+
+        Returns True if:
+        - blocked_by_ticket_id is set, AND
+        - The blocking ticket's state is NOT 'done'
+
+        Note: This requires the blocked_by relationship to be loaded.
+        Use selectinload(Ticket.blocked_by) when querying.
+        """
+        if not self.blocked_by_ticket_id:
+            return False
+        if self.blocked_by is None:
+            # Relationship not loaded - assume blocked for safety
+            return True
+        return self.blocked_by.state != TicketState.DONE.value
+
+    @property
+    def verification_commands(self) -> list[str]:
+        """Get verification commands as a list."""
+        if not self.verification_commands_json:
+            return []
+        try:
+            return json.loads(self.verification_commands_json)
+        except (json.JSONDecodeError, TypeError):
+            return []
+
+    @verification_commands.setter
+    def verification_commands(self, commands: list[str]) -> None:
+        """Set verification commands from a list with validation."""
+        if not commands:
+            self.verification_commands_json = None
+            return
+
+        # Validation constants
+        MAX_COMMANDS = 5
+        MAX_CMD_LENGTH = 500
+
+        # Validate and sanitize
+        validated = []
+        for cmd in commands[:MAX_COMMANDS]:
+            if not isinstance(cmd, str):
+                continue
+            # Truncate if too long
+            cmd = cmd[:MAX_CMD_LENGTH].strip()
+            # Skip empty commands
+            if not cmd:
+                continue
+            # Remove null bytes and control chars
+            cmd = "".join(c for c in cmd if ord(c) >= 32 or c in "\t\n\r")
+            validated.append(cmd)
+
+        if validated:
+            self.verification_commands_json = json.dumps(validated)
+        else:
+            self.verification_commands_json = None
+
+    def __repr__(self) -> str:
+        return f"<Ticket(id={self.id}, title={self.title}, state={self.state})>"

package/app/backend/app/models/ticket_event.py

@@ -0,0 +1,83 @@
+"""TicketEvent model for Draft - append-only event log."""
+
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from sqlalchemy import DateTime, ForeignKey, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+if TYPE_CHECKING:
+    from app.models.ticket import Ticket
+
+
+class TicketEvent(Base):
+    """
+    TicketEvent model for recording all ticket state changes and actions.
+
+    This is an append-only log - events should never be updated or deleted.
+    """
+
+    __tablename__ = "ticket_events"
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    ticket_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("tickets.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    event_type: Mapped[str] = mapped_column(
+        String(50),
+        nullable=False,
+    )
+    from_state: Mapped[str | None] = mapped_column(
+        String(50),
+        nullable=True,
+    )
+    to_state: Mapped[str | None] = mapped_column(
+        String(50),
+        nullable=True,
+    )
+    actor_type: Mapped[str] = mapped_column(
+        String(50),
+        nullable=False,
+    )
+    actor_id: Mapped[str | None] = mapped_column(
+        String(255),
+        nullable=True,
+    )
+    reason: Mapped[str | None] = mapped_column(
+        Text,
+        nullable=True,
+    )
+    payload_json: Mapped[str | None] = mapped_column(
+        Text,
+        nullable=True,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+        index=True,
+    )
+
+    # Relationships
+    ticket: Mapped["Ticket"] = relationship("Ticket", back_populates="events")
+
+    def get_payload(self) -> dict[str, Any] | None:
+        """Parse and return the payload as a dictionary."""
+        if self.payload_json is None:
+            return None
+        import json
+
+        return json.loads(self.payload_json)
+
+    def __repr__(self) -> str:
+        return f"<TicketEvent(id={self.id}, type={self.event_type}, ticket_id={self.ticket_id})>"

package/app/backend/app/models/user.py

@@ -0,0 +1,47 @@
+"""User model for multi-user authentication."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Boolean, DateTime, String, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+
+class User(Base):
+    """User account for authentication and board ownership.
+
+    Each user has their own set of boards. Boards are scoped by owner_id.
+    """
+
+    __tablename__ = "users"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    email: Mapped[str] = mapped_column(
+        String(255), unique=True, nullable=False, index=True
+    )
+    display_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
+    is_active: Mapped[bool] = mapped_column(
+        Boolean, default=True, server_default="1", nullable=False
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    # Relationships
+    boards: Mapped[list["Board"]] = relationship(  # noqa: F821
+        "Board", back_populates="owner", cascade="all, delete-orphan"
+    )
+
+    def __repr__(self) -> str:
+        return f"<User(id={self.id}, email={self.email})>"

package/app/backend/app/models/workspace.py

@@ -0,0 +1,71 @@
+"""Workspace model for git worktree isolation."""
+
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, ForeignKey, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+if TYPE_CHECKING:
+    from app.models.board import Board
+    from app.models.ticket import Ticket
+
+
+class Workspace(Base):
+    """Workspace model representing an isolated git worktree for a ticket.
+
+    IMPORTANT: Workspaces are scoped by board_id for permission enforcement.
+    """
+
+    __tablename__ = "workspaces"
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4()),
+    )
+    board_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("boards.id", ondelete="CASCADE"),
+        nullable=True,  # Nullable for migration compatibility
+        index=True,
+    )
+    ticket_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("tickets.id", ondelete="CASCADE"),
+        nullable=False,
+        unique=True,
+        index=True,
+    )
+    worktree_path: Mapped[str] = mapped_column(
+        Text,
+        nullable=False,
+    )
+    branch_name: Mapped[str] = mapped_column(
+        Text,
+        nullable=False,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        server_default=func.now(),
+        nullable=False,
+    )
+    cleaned_up_at: Mapped[datetime | None] = mapped_column(
+        DateTime,
+        nullable=True,
+    )
+
+    # Relationships
+    board: Mapped["Board | None"] = relationship("Board", back_populates="workspaces")
+    ticket: Mapped["Ticket"] = relationship("Ticket", back_populates="workspace")
+
+    @property
+    def is_active(self) -> bool:
+        """Check if the workspace is still active (not cleaned up)."""
+        return self.cleaned_up_at is None
+
+    def __repr__(self) -> str:
+        return f"<Workspace(id={self.id}, ticket_id={self.ticket_id}, branch={self.branch_name})>"

package/app/backend/app/redis_client.py

@@ -0,0 +1,119 @@
+"""In-memory cache for idempotency, rate limiting, and transient data.
+
+Provides a simple dict-based cache with TTL support. Used by middleware
+and services for short-lived data that doesn't need disk persistence.
+"""
+
+import logging
+import time
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_cache_instance: "InMemoryCache | None" = None
+
+
+class InMemoryCache:
+    """In-memory cache with TTL support.
+
+    Provides a Redis-compatible interface for single-process operation.
+    """
+
+    def __init__(self):
+        self._data: dict[str, Any] = {}
+        self._expiry: dict[str, float] = {}
+
+    def _check_expired(self, key: str) -> bool:
+        """Check if a key has expired and delete it if so."""
+        if key in self._expiry:
+            if time.time() > self._expiry[key]:
+                del self._data[key]
+                del self._expiry[key]
+                return True
+        return False
+
+    def get(self, key: str) -> Any | None:
+        """Get value for key, returns None if not found or expired."""
+        if self._check_expired(key):
+            return None
+        return self._data.get(key)
+
+    def set(self, key: str, value: Any, ex: int | None = None) -> bool:
+        """Set key to value with optional expiry in seconds."""
+        self._data[key] = value
+        if ex is not None:
+            self._expiry[key] = time.time() + ex
+        elif key in self._expiry:
+            del self._expiry[key]
+        return True
+
+    def setex(self, key: str, time_seconds: int, value: Any) -> bool:
+        """Set key with expiry."""
+        return self.set(key, value, ex=time_seconds)
+
+    def delete(self, *keys: str) -> int:
+        """Delete one or more keys, returns count of deleted keys."""
+        count = 0
+        for key in keys:
+            if key in self._data:
+                del self._data[key]
+                count += 1
+            if key in self._expiry:
+                del self._expiry[key]
+        return count
+
+    def setnx(self, key: str, value: Any) -> bool:
+        """Set key only if it doesn't exist. Returns True if set, False otherwise."""
+        if self._check_expired(key):
+            pass
+        elif key in self._data:
+            return False
+
+        self._data[key] = value
+        return True
+
+    def exists(self, *keys: str) -> int:
+        """Check if keys exist, returns count of existing keys."""
+        count = 0
+        for key in keys:
+            if not self._check_expired(key) and key in self._data:
+                count += 1
+        return count
+
+    def expire(self, key: str, time_seconds: int) -> bool:
+        """Set expiry on existing key."""
+        if key not in self._data or self._check_expired(key):
+            return False
+        self._expiry[key] = time.time() + time_seconds
+        return True
+
+    def ttl(self, key: str) -> int:
+        """Get time to live for key. Returns -1 if no expiry, -2 if not found."""
+        if self._check_expired(key) or key not in self._data:
+            return -2
+        if key not in self._expiry:
+            return -1
+        remaining = int(self._expiry[key] - time.time())
+        return max(0, remaining)
+
+    def ping(self) -> bool:
+        return True
+
+    def close(self) -> None:
+        pass
+
+
+def get_redis() -> InMemoryCache:
+    """Get the shared in-memory cache instance."""
+    global _cache_instance
+    if _cache_instance is None:
+        _cache_instance = InMemoryCache()
+    return _cache_instance
+
+
+def close_redis() -> None:
+    """Clear the cache (call on shutdown)."""
+    global _cache_instance
+    if _cache_instance:
+        _cache_instance.close()
+        _cache_instance = None

package/app/backend/app/routers/__init__.py

@@ -0,0 +1,29 @@
+"""API routers for Draft."""
+
+from app.routers.board import legacy_router as board_legacy_router
+from app.routers.board import router as boards_router
+from app.routers.debug import router as debug_router
+from app.routers.evidence import router as evidence_router
+from app.routers.goals import router as goals_router
+from app.routers.jobs import router as jobs_router
+from app.routers.maintenance import router as maintenance_router
+from app.routers.merge import router as merge_router
+from app.routers.planner import router as planner_router
+from app.routers.repos import router as repos_router
+from app.routers.revisions import router as revisions_router
+from app.routers.tickets import router as tickets_router
+
+__all__ = [
+    "goals_router",
+    "tickets_router",
+    "boards_router",
+    "board_legacy_router",
+    "repos_router",
+    "jobs_router",
+    "evidence_router",
+    "planner_router",
+    "revisions_router",
+    "merge_router",
+    "maintenance_router",
+    "debug_router",
+]