draft-board 0.1.0-beta.0

package/app/backend/alembic/versions/add_repos_and_board_repos.py

@@ -0,0 +1,174 @@
+"""add_repos_and_board_repos
+
+Revision ID: add_repos_001
+Revises: 357c780ee445
+Create Date: 2026-01-29 22:00:00.000000
+
+"""
+
+import uuid
+from collections.abc import Sequence
+from pathlib import Path
+
+import sqlalchemy as sa
+from sqlalchemy.sql import column, table
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "add_repos_001"
+down_revision: str | None = "357c780ee445"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # Create repos table
+    op.create_table(
+        "repos",
+        sa.Column("id", sa.String(length=36), nullable=False),
+        sa.Column("path", sa.String(length=1024), nullable=False),
+        sa.Column("name", sa.String(length=255), nullable=False),
+        sa.Column("display_name", sa.String(length=255), nullable=False),
+        sa.Column("setup_script", sa.Text(), nullable=True),
+        sa.Column("cleanup_script", sa.Text(), nullable=True),
+        sa.Column("dev_server_script", sa.Text(), nullable=True),
+        sa.Column("default_branch", sa.String(length=255), nullable=True),
+        sa.Column("remote_url", sa.String(length=1024), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(),
+            server_default=sa.text("(CURRENT_TIMESTAMP)"),
+            nullable=False,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(),
+            server_default=sa.text("(CURRENT_TIMESTAMP)"),
+            nullable=False,
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("path", name="uq_repo_path"),
+    )
+    op.create_index(op.f("ix_repos_path"), "repos", ["path"], unique=True)
+
+    # Create board_repos junction table
+    op.create_table(
+        "board_repos",
+        sa.Column("id", sa.String(length=36), nullable=False),
+        sa.Column("board_id", sa.String(length=36), nullable=False),
+        sa.Column("repo_id", sa.String(length=36), nullable=False),
+        sa.Column("is_primary", sa.Boolean(), nullable=False, server_default="0"),
+        sa.Column("custom_setup_script", sa.Text(), nullable=True),
+        sa.Column("custom_cleanup_script", sa.Text(), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(),
+            server_default=sa.text("(CURRENT_TIMESTAMP)"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(["board_id"], ["boards.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["repo_id"], ["repos.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("board_id", "repo_id", name="uq_board_repo"),
+    )
+    op.create_index(
+        op.f("ix_board_repos_board_id"), "board_repos", ["board_id"], unique=False
+    )
+    op.create_index(
+        op.f("ix_board_repos_repo_id"), "board_repos", ["repo_id"], unique=False
+    )
+
+    # Migrate existing boards.repo_root to new structure
+    # Note: This is a data migration, so we need to use SQLAlchemy core
+
+    # Define table structures for data migration
+    boards = table(
+        "boards",
+        column("id", sa.String),
+        column("repo_root", sa.String),
+        column("default_branch", sa.String),
+    )
+
+    repos_table = table(
+        "repos",
+        column("id", sa.String),
+        column("path", sa.String),
+        column("name", sa.String),
+        column("display_name", sa.String),
+        column("default_branch", sa.String),
+    )
+
+    board_repos_table = table(
+        "board_repos",
+        column("id", sa.String),
+        column("board_id", sa.String),
+        column("repo_id", sa.String),
+        column("is_primary", sa.Boolean),
+    )
+
+    # Get connection
+    conn = op.get_bind()
+
+    # Fetch all boards with repo_root
+    result = conn.execute(
+        sa.select(boards.c.id, boards.c.repo_root, boards.c.default_branch)
+    )
+    board_data = result.fetchall()
+
+    # For each board, create a repo and link it
+    for board_id, repo_root, default_branch in board_data:
+        if not repo_root:
+            continue
+
+        # Generate repo ID
+        repo_id = str(uuid.uuid4())
+
+        # Extract repo name from path
+        try:
+            repo_name = Path(repo_root).name
+        except Exception:
+            repo_name = "repository"
+
+        # Insert repo
+        conn.execute(
+            repos_table.insert().values(
+                id=repo_id,
+                path=repo_root,
+                name=repo_name,
+                display_name=repo_name,
+                default_branch=default_branch,
+            )
+        )
+
+        # Link board to repo (as primary)
+        board_repo_id = str(uuid.uuid4())
+        conn.execute(
+            board_repos_table.insert().values(
+                id=board_repo_id, board_id=board_id, repo_id=repo_id, is_primary=True
+            )
+        )
+
+    # Make repo_root nullable (backwards compatibility - keep for now)
+    # In a future migration, we can remove it entirely
+    with op.batch_alter_table("boards", schema=None) as batch_op:
+        batch_op.alter_column(
+            "repo_root", existing_type=sa.String(length=1024), nullable=True
+        )
+
+
+def downgrade() -> None:
+    # Drop board_repos table
+    op.drop_index(op.f("ix_board_repos_repo_id"), table_name="board_repos")
+    op.drop_index(op.f("ix_board_repos_board_id"), table_name="board_repos")
+    op.drop_table("board_repos")
+
+    # Drop repos table
+    op.drop_index(op.f("ix_repos_path"), table_name="repos")
+    op.drop_table("repos")
+
+    # Restore repo_root to non-nullable
+    with op.batch_alter_table("boards", schema=None) as batch_op:
+        batch_op.alter_column(
+            "repo_root", existing_type=sa.String(length=1024), nullable=False
+        )

package/app/backend/alembic/versions/add_session_id_to_jobs.py

@@ -0,0 +1,27 @@
+"""Add session_id column to jobs table for executor session resume.
+
+Revision ID: a1b2c3d4e5f6
+Revises: 7b307e847cbd
+Create Date: 2026-02-16 15:00:00.000000
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "a1b2c3d4e5f6"
+down_revision: str | None = "7b307e847cbd"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column("jobs", sa.Column("session_id", sa.String(255), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("jobs", "session_id")

package/app/backend/alembic/versions/add_sqlite_backend_tables.py

@@ -0,0 +1,104 @@
+"""add_sqlite_backend_tables
+
+Revision ID: c3a8f1b2d4e5
+Revises: b10fb0b62240
+Create Date: 2026-02-15 10:00:00.000000
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "c3a8f1b2d4e5"
+down_revision: str | None = "b10fb0b62240"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # Job queue (replaces Celery broker)
+    op.create_table(
+        "job_queue",
+        sa.Column("id", sa.String(36), primary_key=True),
+        sa.Column("task_name", sa.String(255), nullable=False),
+        sa.Column("args_json", sa.Text(), nullable=False, server_default="[]"),
+        sa.Column("status", sa.String(20), nullable=False, server_default="pending"),
+        sa.Column("claimed_by", sa.String(255), nullable=True),
+        sa.Column("claimed_at", sa.DateTime(), nullable=True),
+        sa.Column("completed_at", sa.DateTime(), nullable=True),
+        sa.Column("result_json", sa.Text(), nullable=True),
+        sa.Column("priority", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column(
+            "created_at",
+            sa.DateTime(),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+    )
+    op.create_index("ix_job_queue_status", "job_queue", ["status"])
+    op.create_index(
+        "ix_job_queue_claim_order",
+        "job_queue",
+        ["status", "priority", "created_at"],
+    )
+
+    # Idempotency cache (replaces Redis SETNX + result cache)
+    op.create_table(
+        "idempotency_cache",
+        sa.Column("cache_key", sa.String(512), primary_key=True),
+        sa.Column("lock_value", sa.Text(), nullable=True),
+        sa.Column("result_value", sa.Text(), nullable=True),
+        sa.Column("lock_expires_at", sa.DateTime(), nullable=True),
+        sa.Column("result_expires_at", sa.DateTime(), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+    )
+
+    # Rate limit entries (replaces Redis sorted sets)
+    op.create_table(
+        "rate_limit_entries",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("client_key", sa.String(255), nullable=False),
+        sa.Column("cost", sa.Integer(), nullable=False, server_default="1"),
+        sa.Column("recorded_at", sa.Float(), nullable=False),
+        sa.Column("expires_at", sa.Float(), nullable=False),
+    )
+    op.create_index(
+        "ix_rate_limit_entries_client_key",
+        "rate_limit_entries",
+        ["client_key"],
+    )
+    op.create_index(
+        "ix_rate_limit_entries_expires_at",
+        "rate_limit_entries",
+        ["expires_at"],
+    )
+
+    # KV store (replaces Redis GET/SET for queued messages)
+    op.create_table(
+        "kv_store",
+        sa.Column("key", sa.String(512), primary_key=True),
+        sa.Column("value", sa.Text(), nullable=False),
+        sa.Column("expires_at", sa.DateTime(), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("kv_store")
+    op.drop_table("rate_limit_entries")
+    op.drop_table("idempotency_cache")
+    op.drop_table("job_queue")

package/app/backend/alembic/versions/b10fb0b62240_add_diff_content_to_revisions.py

@@ -0,0 +1,34 @@
+"""add_diff_content_to_revisions
+
+Revision ID: b10fb0b62240
+Revises: 9d17f0698d3b
+Create Date: 2026-02-10 07:08:55.015460
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "b10fb0b62240"
+down_revision: str | None = "9d17f0698d3b"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # Add diff content columns to store diffs permanently in DB
+    # This preserves diffs even after worktree/evidence cleanup
+    op.add_column("revisions", sa.Column("diff_stat_content", sa.Text(), nullable=True))
+    op.add_column(
+        "revisions", sa.Column("diff_patch_content", sa.Text(), nullable=True)
+    )
+
+
+def downgrade() -> None:
+    # Remove diff content columns
+    op.drop_column("revisions", "diff_patch_content")
+    op.drop_column("revisions", "diff_stat_content")

package/app/backend/alembic.ini

@@ -0,0 +1,89 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# file_template = %%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# version path separator; As mentioned above, this is around a ';' character 
+# by default, but may be changed with the '--sep' flag to 'alembic init'.
+# version_path_separator = os
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = sqlite:///./kanban.db
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -q
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
+
+

package/app/backend/app/__init__.py

@@ -0,0 +1,3 @@
+# Draft Backend
+
+

package/app/backend/app/data_dir.py

@@ -0,0 +1,85 @@
+"""Central data directory for Draft runtime artifacts.
+
+All worktrees, logs, and evidence files live under a single central
+directory (~/.draft/ by default) instead of polluting target repos.
+
+Override with the DRAFT_DATA_DIR environment variable.
+"""
+
+import os
+from pathlib import Path
+
+_DEFAULT_DATA_DIR = Path.home() / ".draft"
+
+
+def get_data_dir() -> Path:
+    """Return the central data directory, creating it if needed.
+
+    Resolution order:
+        1. DRAFT_DATA_DIR environment variable
+        2. ~/.draft/
+    """
+    data_dir = Path(os.environ.get("DRAFT_DATA_DIR", str(_DEFAULT_DATA_DIR)))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+def get_worktree_dir(board_id: str, ticket_id: str) -> Path:
+    """Return the worktree directory for a ticket.
+
+    Layout: {data_dir}/worktrees/{board_id}/{ticket_id}/
+    """
+    return get_data_dir() / "worktrees" / board_id / ticket_id
+
+
+def get_worktrees_root() -> Path:
+    """Return the root worktrees directory.
+
+    Layout: {data_dir}/worktrees/
+    """
+    return get_data_dir() / "worktrees"
+
+
+def get_log_path(job_id: str) -> Path:
+    """Return the log file path for a job.
+
+    Layout: {data_dir}/logs/{job_id}.log
+    """
+    logs_dir = get_logs_dir()
+    logs_dir.mkdir(parents=True, exist_ok=True)
+    return logs_dir / f"{job_id}.log"
+
+
+def get_logs_dir() -> Path:
+    """Return the central logs directory.
+
+    Layout: {data_dir}/logs/
+    """
+    d = get_data_dir() / "logs"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def get_evidence_dir(job_id: str) -> Path:
+    """Return the evidence directory for a job.
+
+    Layout: {data_dir}/evidence/{job_id}/
+    """
+    d = get_data_dir() / "evidence" / job_id
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def get_jobs_dir(job_id: str) -> Path:
+    """Return the job working directory.
+
+    Layout: {data_dir}/jobs/{job_id}/
+    """
+    d = get_data_dir() / "jobs" / job_id
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+# Legacy path constant for migration-period checks
+LEGACY_DRAFT_DIR = ".draft"
+LEGACY_WORKTREES_DIR = ".draft/worktrees"

package/app/backend/app/database.py

@@ -0,0 +1,70 @@
+"""Database connection and session management for Draft."""
+
+import os
+from collections.abc import AsyncGenerator
+from pathlib import Path
+
+from sqlalchemy import event
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from app.models.base import Base
+
+# Get the backend directory (where this file lives is app/, so go up one level)
+_BACKEND_DIR = Path(__file__).parent.parent.resolve()
+
+# Database URL - defaults to SQLite file in the backend directory
+# Use absolute path to ensure consistency across different working directories
+DATABASE_URL = os.getenv(
+    "DATABASE_URL", f"sqlite+aiosqlite:///{_BACKEND_DIR}/kanban.db"
+)
+
+_is_sqlite = "sqlite" in DATABASE_URL
+
+# Create async engine with SQLite-friendly settings
+engine = create_async_engine(
+    DATABASE_URL,
+    echo=os.getenv("SQL_ECHO", "false").lower() == "true",
+    future=True,
+    connect_args={"timeout": 30} if _is_sqlite else {},
+    pool_pre_ping=True,
+)
+
+
+# Enable WAL mode for SQLite to prevent readers from blocking writers
+if _is_sqlite:
+
+    @event.listens_for(engine.sync_engine, "connect")
+    def _set_sqlite_pragma(dbapi_conn, connection_record):
+        cursor = dbapi_conn.cursor()
+        cursor.execute("PRAGMA journal_mode=WAL")
+        cursor.execute("PRAGMA busy_timeout=30000")
+        cursor.close()
+
+
+# Session factory
+async_session_maker = async_sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
+)
+
+
+async def init_db() -> None:
+    """Initialize the database by creating all tables."""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """Dependency for FastAPI to inject database sessions."""
+    async with async_session_maker() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()

package/app/backend/app/database_sync.py

@@ -0,0 +1,64 @@
+"""Synchronous database connection for Celery workers."""
+
+import os
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+
+from sqlalchemy import create_engine, event
+from sqlalchemy.orm import Session, sessionmaker
+
+# Get the backend directory (where this file lives is app/, so go up one level)
+_BACKEND_DIR = Path(__file__).parent.parent.resolve()
+
+# Synchronous database URL - defaults to SQLite file in the backend directory
+# Use absolute path to ensure worker finds the same database as the server
+DATABASE_URL = os.getenv("DATABASE_URL", f"sqlite:///{_BACKEND_DIR}/kanban.db")
+if DATABASE_URL.startswith("sqlite+aiosqlite"):
+    DATABASE_URL = DATABASE_URL.replace("sqlite+aiosqlite", "sqlite")
+
+_is_sqlite = DATABASE_URL.startswith("sqlite")
+
+# Create synchronous engine with SQLite-friendly settings
+sync_engine = create_engine(
+    DATABASE_URL,
+    echo=os.getenv("SQL_ECHO", "false").lower() == "true",
+    future=True,
+    connect_args={"timeout": 30} if _is_sqlite else {},
+    pool_pre_ping=True,
+)
+
+
+# Enable WAL mode for SQLite to prevent readers from blocking writers
+if _is_sqlite:
+
+    @event.listens_for(sync_engine, "connect")
+    def _set_sqlite_pragma(dbapi_conn, connection_record):
+        cursor = dbapi_conn.cursor()
+        cursor.execute("PRAGMA journal_mode=WAL")
+        cursor.execute("PRAGMA busy_timeout=30000")
+        cursor.close()
+
+
+# Synchronous session factory
+SyncSessionLocal = sessionmaker(
+    bind=sync_engine,
+    class_=Session,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
+)
+
+
+@contextmanager
+def get_sync_db() -> Generator[Session, None, None]:
+    """Context manager for synchronous database sessions (used by Celery workers)."""
+    session = SyncSessionLocal()
+    try:
+        yield session
+        session.commit()
+    except Exception:
+        session.rollback()
+        raise
+    finally:
+        session.close()

package/app/backend/app/dependencies/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI dependency injection utilities."""
+
+from app.dependencies.auth import get_current_user, get_optional_user
+
+__all__ = ["get_current_user", "get_optional_user"]