@kernel-sig/console 0.1.0

package/backend/app/api/v1/pulls.py

@@ -0,0 +1,388 @@
+"""Pull Request API。
+
+列表支持组合筛选 —— 这是维护者日常使用的主入口：
+1124+ 个 open PR，没有强筛选等于没有列表。
+"""
+
+import uuid
+from datetime import UTC, datetime, timedelta
+from typing import Annotated, Literal
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy import func, select
+
+from app.api.deps import CurrentUserDep, SessionDep, require_permission
+from app.core.exceptions import NotFoundError
+from app.core.permissions import Permission
+from app.domain.review import derive_gate, is_bot
+from app.models.classification import PRKind, SubjectType
+from app.models.pull_request import PRComment, PRCommit, PRFile, PullRequest, ReviewEvent
+from app.schemas.common import MessageResponse, Page
+from app.schemas.pull_request import (
+    FacetRead,
+    FacetResponse,
+    FacetValueRead,
+    PRCommentRead,
+    PRCommitRead,
+    PRFileRead,
+    PullDetail,
+    PullListItem,
+    PullSummary,
+    ReviewEventRead,
+    StageCount,
+)
+from app.services import (
+    classification_service,
+    pull_query,
+    release_service,
+    repository_service,
+)
+
+router = APIRouter(tags=["pulls"])
+
+SortField = Literal["updated", "created", "waiting", "lines", "comments"]
+
+SORT_COLUMNS = {
+    "updated": PullRequest.atomgit_updated_at,
+    "created": PullRequest.atomgit_created_at,
+    # 等待时长：创建越早、仍处于待评审，等待越久
+    "waiting": PullRequest.atomgit_created_at,
+    "lines": (PullRequest.added_lines + PullRequest.removed_lines),
+    "comments": PullRequest.comments_count,
+}
+
+
+async def _branch_alias(session: SessionDep, repository_id: uuid.UUID) -> dict[str, list[str]]:
+    """规范化分支名 → 库中实际写法的映射。
+
+    分面里显示的是规范化名（同一个交付的不同写法已合并），而筛选时要展开成
+    库里的原始写法 —— 不展开就会"勾了却空结果"。
+    """
+    rows = await release_service.list_branches(session, repository_id)
+    return {row.name: row.raw_names for row in rows}
+
+
+def _selection(
+    *,
+    state: str | None,
+    stage: list[str] | None,
+    kind: list[str] | None,
+    branch: list[str] | None,
+    author: list[str] | None,
+    attention: list[str] | None,
+    draft: bool | None,
+    conflict: bool | None,
+    q: str | None,
+    waiting_days_gte: int | None,
+) -> pull_query.Selection:
+    return pull_query.Selection(
+        state=None if state == "all" else state,
+        stage=list(stage or []),
+        kind=list(kind or []),
+        branch=list(branch or []),
+        author=list(author or []),
+        attention=list(attention or []),
+        draft=draft,
+        conflict=conflict,
+        search=q,
+        waiting_days_gte=waiting_days_gte,
+    )
+
+
+@router.get("/repositories/{repository_id}/pulls", response_model=Page[PullListItem])
+async def list_pulls(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    state: Annotated[str | None, Query(pattern="^(open|closed|merged|all)$")] = "open",
+    stage: Annotated[list[str] | None, Query()] = None,
+    kind: Annotated[list[PRKind] | None, Query()] = None,
+    branch: Annotated[list[str] | None, Query()] = None,
+    author: Annotated[list[str] | None, Query()] = None,
+    attention: Annotated[list[str] | None, Query()] = None,
+    draft: bool | None = None,
+    has_conflict: bool | None = None,
+    q: str | None = None,
+    waiting_days_gte: int | None = None,
+    sort: SortField = "updated",
+    order: Annotated[Literal["asc", "desc"], Query()] = "desc",
+    page: Annotated[int, Query(ge=1)] = 1,
+    per_page: Annotated[int, Query(ge=1, le=200)] = 50,
+) -> Page[PullListItem]:
+    await repository_service.require_repository(session, repository_id)
+    alias = await _branch_alias(session, repository_id)
+
+    # 筛选逻辑与分面共用同一份定义（pull_query），否则会出现
+    # "列表 12 条、分面计数 15" 这种没人能一眼看出的偏差
+    selection = _selection(
+        state=state,
+        stage=stage,
+        kind=[item.value for item in kind] if kind else None,
+        branch=branch,
+        author=author,
+        attention=attention,
+        draft=draft,
+        conflict=has_conflict,
+        q=q,
+        waiting_days_gte=waiting_days_gte,
+    )
+    base = pull_query.apply_filters(
+        select(PullRequest), repository_id, selection, branch_alias=alias
+    )
+
+    total = await session.scalar(select(func.count()).select_from(base.subquery())) or 0
+
+    column = SORT_COLUMNS[sort]
+    ordered = base.order_by(
+        column.asc() if order == "asc" else column.desc(), PullRequest.number.desc()
+    )
+    pulls = list(
+        (await session.scalars(ordered.offset((page - 1) * per_page).limit(per_page))).all()
+    )
+
+    # 一次性取回本页的分类，避免逐条查询。列表页看不到类别的话，
+    # 分类就只能在详情页一条条点开看 —— 那等于没做分流。
+    classified = await classification_service.classifications_for(
+        session, SubjectType.PULL_REQUEST, [pull.id for pull in pulls]
+    )
+    items = [
+        PullListItem(
+            **PullSummary.model_validate(pull).model_dump(),
+            kind=classified[pull.id].kind if pull.id in classified else None,
+        )
+        for pull in pulls
+    ]
+    return Page.create(items, total, page, per_page)
+
+
+@router.get("/repositories/{repository_id}/pulls/facets", response_model=FacetResponse)
+async def pull_facets(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    state: Annotated[str | None, Query(pattern="^(open|closed|merged|all)$")] = "open",
+    stage: Annotated[list[str] | None, Query()] = None,
+    kind: Annotated[list[PRKind] | None, Query()] = None,
+    branch: Annotated[list[str] | None, Query()] = None,
+    author: Annotated[list[str] | None, Query()] = None,
+    attention: Annotated[list[str] | None, Query()] = None,
+    draft: bool | None = None,
+    has_conflict: bool | None = None,
+    q: str | None = None,
+    waiting_days_gte: int | None = None,
+) -> FacetResponse:
+    """各筛选维度的取值与计数。
+
+    某一维度的计数**不含该维度自身的筛选**：勾上 CVE 之后，分支一栏仍然
+    给出各分支的真实数量，使用者才能在此基础上继续放宽或收窄。
+    少了这一条，分面就退化成只能全部清空的单选列表。
+    """
+    await repository_service.require_repository(session, repository_id)
+    alias = await _branch_alias(session, repository_id)
+
+    selection = _selection(
+        state=state,
+        stage=stage,
+        kind=[item.value for item in kind] if kind else None,
+        branch=branch,
+        author=author,
+        attention=attention,
+        draft=draft,
+        conflict=has_conflict,
+        q=q,
+        waiting_days_gte=waiting_days_gte,
+    )
+    facets = await pull_query.build_facets(session, repository_id, selection, branch_alias=alias)
+    matched = await session.scalar(
+        select(func.count()).select_from(
+            pull_query.apply_filters(
+                select(PullRequest), repository_id, selection, branch_alias=alias
+            ).subquery()
+        )
+    )
+    return FacetResponse(
+        total=matched or 0,
+        facets=[
+            FacetRead(
+                key=facet.key,
+                label=facet.label,
+                values=[
+                    FacetValueRead(
+                        value=item.value,
+                        label=item.label,
+                        count=item.count,
+                        selected=item.selected,
+                    )
+                    for item in facet.values
+                ],
+            )
+            for facet in facets
+        ],
+    )
+
+
+@router.get("/repositories/{repository_id}/pulls/stage-counts", response_model=list[StageCount])
+async def stage_counts(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    state: str | None = "open",
+) -> list[StageCount]:
+    """各门禁阶段的 PR 数量，用于列表页的筛选标签。
+
+    只统计指定状态的 PR：把已合并的数量混进来会淹没待办。
+    """
+    await repository_service.require_repository(session, repository_id)
+    stmt = select(PullRequest.gate_stage, func.count()).where(
+        PullRequest.repository_id == repository_id
+    )
+    if state:
+        stmt = stmt.where(PullRequest.state == state)
+    rows = (await session.execute(stmt.group_by(PullRequest.gate_stage))).all()
+    return [StageCount(stage=row[0], count=row[1]) for row in rows]
+
+
+@router.get("/repositories/{repository_id}/pulls/authors", response_model=list[str])
+async def pull_authors(
+    repository_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> list[str]:
+    """出现过的作者列表，供筛选下拉使用。"""
+    stmt = (
+        select(PullRequest.author_login)
+        .where(
+            PullRequest.repository_id == repository_id,
+            PullRequest.author_login.is_not(None),
+        )
+        .group_by(PullRequest.author_login)
+        .order_by(func.count().desc())
+        .limit(100)
+    )
+    return [row for row in (await session.scalars(stmt)).all() if row]
+
+
+@router.get("/repositories/{repository_id}/pulls/branches", response_model=list[str])
+async def pull_branches(
+    repository_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> list[str]:
+    stmt = (
+        select(PullRequest.target_branch)
+        .where(
+            PullRequest.repository_id == repository_id,
+            PullRequest.target_branch.is_not(None),
+        )
+        .group_by(PullRequest.target_branch)
+        .order_by(func.count().desc())
+    )
+    return [row for row in (await session.scalars(stmt)).all() if row]
+
+
+async def _require_pull(session: SessionDep, pull_id: uuid.UUID) -> PullRequest:
+    pull = await session.get(PullRequest, pull_id)
+    if pull is None:
+        raise NotFoundError("PR 不存在", resource="pull_request", identifier=str(pull_id))
+    return pull
+
+
+@router.get("/pulls/{pull_id}", response_model=PullDetail)
+async def get_pull(pull_id: uuid.UUID, session: SessionDep, _: CurrentUserDep) -> PullDetail:
+    pull = await _require_pull(session, pull_id)
+
+    commits = (
+        await session.scalars(
+            select(PRCommit).where(PRCommit.pull_request_id == pull_id).order_by(PRCommit.sequence)
+        )
+    ).all()
+    files = (
+        await session.scalars(
+            select(PRFile).where(PRFile.pull_request_id == pull_id).order_by(PRFile.filename)
+        )
+    ).all()
+    events = (
+        await session.scalars(
+            select(ReviewEvent)
+            .where(ReviewEvent.pull_request_id == pull_id)
+            .order_by(ReviewEvent.occurred_at)
+        )
+    ).all()
+
+    comments = (
+        await session.scalars(
+            select(PRComment)
+            .where(PRComment.pull_request_id == pull_id)
+            .order_by(PRComment.atomgit_created_at, PRComment.id)
+        )
+    ).all()
+
+    # 门禁由后端推导后下发，前端无需复刻规则 —— 规则只有一份，不会前后端漂移
+    gate = derive_gate(pull.label_names or [], is_draft=pull.draft, state=pull.state)
+
+    detail = PullDetail.model_validate(pull)
+    detail.body = pull.body
+    detail.source_branch = pull.source_branch
+    detail.mergeable = pull.mergeable
+    detail.mergeable_detail = pull.merge_check_detail
+    detail.blocking_reasons = gate.blocking_reasons
+    detail.ready_to_merge = gate.ready_to_merge
+    detail.lgtm_actors = sorted(gate.lgtm_actors)
+    detail.commits = [PRCommitRead.model_validate(c) for c in commits]
+    detail.files = [PRFileRead.model_validate(f) for f in files]
+    detail.review_events = [ReviewEventRead.model_validate(e) for e in events]
+    detail.comments = [
+        PRCommentRead(
+            comment_id=comment.comment_id,
+            comment_type=comment.comment_type,
+            author_login=comment.author_login,
+            author_avatar_url=comment.author_avatar_url,
+            body=comment.body,
+            atomgit_created_at=comment.atomgit_created_at,
+            is_bot=is_bot(comment.author_login),
+        )
+        for comment in comments
+    ]
+    return detail
+
+
+@router.post("/pulls/{pull_id}/recompute-gate", response_model=MessageResponse)
+async def recompute_gate(
+    pull_id: uuid.UUID,
+    session: SessionDep,
+    _: Annotated[object, Depends(require_permission(Permission.CLASSIFY))],
+) -> MessageResponse:
+    """按当前标签重算门禁阶段。
+
+    标签在两次同步之间可能被上游改动，提供手动重算入口，
+    避免维护者只能等下一次同步。
+    """
+    pull = await _require_pull(session, pull_id)
+    gate = derive_gate(pull.label_names or [], is_draft=pull.draft, state=pull.state)
+    previous, pull.gate_stage = pull.gate_stage, gate.stage.value
+    await session.commit()
+    return MessageResponse(
+        message=f"门禁阶段已从 {previous} 更新为 {pull.gate_stage}"
+        if previous != pull.gate_stage
+        else f"门禁阶段未变化（{pull.gate_stage}）"
+    )
+
+
+@router.get("/repositories/{repository_id}/pulls/stale", response_model=list[PullSummary])
+async def stale_pulls(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    days: Annotated[int, Query(ge=1, le=365)] = 30,
+    limit: Annotated[int, Query(ge=1, le=200)] = 50,
+) -> list[PullSummary]:
+    """长期无活动的 PR。关注队列的核心规则之一。"""
+    await repository_service.require_repository(session, repository_id)
+    cutoff_dt = datetime.now(UTC) - timedelta(days=days)
+    stmt = (
+        select(PullRequest)
+        .where(
+            PullRequest.repository_id == repository_id,
+            PullRequest.state == "open",
+            PullRequest.atomgit_updated_at < cutoff_dt,
+        )
+        .order_by(PullRequest.atomgit_updated_at.asc())
+        .limit(limit)
+    )
+    return [PullSummary.model_validate(row) for row in (await session.scalars(stmt)).all()]

package/backend/app/api/v1/repositories.py

@@ -0,0 +1,273 @@
+"""仓库、凭据与同步的 API。"""
+
+import uuid
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Query, status
+from sqlalchemy import func, select
+
+from app.api.deps import CurrentUserDep, SessionDep, SettingsDep, require_permission
+from app.core.exceptions import ConflictError, ExternalServiceError, NotFoundError
+from app.core.permissions import Permission
+from app.integrations.atomgit.client import AtomGitAuthError, AtomGitClient
+from app.models.credential import Credential, CredentialKind
+from app.models.issue import Issue
+from app.models.pull_request import PullRequest
+from app.models.repository import Repository, SyncRun, SyncTrigger
+from app.schemas.common import Page
+from app.schemas.repository import (
+    CredentialCreate,
+    CredentialRead,
+    CredentialRotate,
+    RepositoryCreate,
+    RepositoryRead,
+    RepositoryUpdate,
+    SyncRunRead,
+)
+from app.services import credential_service, repository_service, sync_service
+
+router = APIRouter(tags=["repositories"])
+
+ManageRepo = Annotated[object, Depends(require_permission(Permission.MANAGE_REPOSITORY))]
+ManageCred = Annotated[object, Depends(require_permission(Permission.MANAGE_CREDENTIALS))]
+
+
+# ---------------------------------------------------------------------------
+# 凭据
+# ---------------------------------------------------------------------------
+
+
+@router.get("/credentials", response_model=list[CredentialRead])
+async def list_credentials(
+    session: SessionDep,
+    _: ManageCred,
+    kind: CredentialKind | None = None,
+) -> list[CredentialRead]:
+    items = await credential_service.list_credentials(session, kind=kind)
+    return [CredentialRead.model_validate(item) for item in items]
+
+
+@router.post("/credentials", response_model=CredentialRead, status_code=status.HTTP_201_CREATED)
+async def create_credential(
+    payload: CredentialCreate,
+    session: SessionDep,
+    settings: SettingsDep,
+    user: CurrentUserDep,
+    _: ManageCred,
+) -> CredentialRead:
+    try:
+        credential = await credential_service.create_credential(
+            session,
+            settings,
+            name=payload.name,
+            kind=payload.kind,
+            plaintext=payload.value,
+            meta=payload.meta,
+            created_by=user.id,
+        )
+    except ConflictError:
+        raise
+    await session.commit()
+    return CredentialRead.model_validate(credential)
+
+
+@router.post("/credentials/{credential_id}/verify", response_model=CredentialRead)
+async def verify_credential(
+    credential_id: uuid.UUID, session: SessionDep, settings: SettingsDep, _: ManageCred
+) -> CredentialRead:
+    """用 /user 校验凭据并回显账号名，让配置者确认 token 配对无误。"""
+    credential = await credential_service.require_credential(session, credential_id)
+
+    try:
+        async with AtomGitClient(credential_service.reveal(settings, credential)) as client:
+            account = await client.get_authenticated_user()
+    except AtomGitAuthError as exc:
+        credential_service.mark_verified(credential, error=str(exc))
+        await session.commit()
+        raise ExternalServiceError(str(exc)) from exc
+    except Exception as exc:
+        credential_service.mark_verified(credential, error=str(exc))
+        await session.commit()
+        raise ExternalServiceError(f"凭据校验失败：{exc}") from exc
+
+    credential_service.mark_verified(credential)
+    credential.meta = {**(credential.meta or {}), "login": account.login}
+    await session.commit()
+    return CredentialRead.model_validate(credential)
+
+
+@router.post("/credentials/{credential_id}/rotate", response_model=CredentialRead)
+async def rotate_credential(
+    credential_id: uuid.UUID,
+    payload: CredentialRotate,
+    session: SessionDep,
+    settings: SettingsDep,
+    _: ManageCred,
+) -> CredentialRead:
+    credential = await credential_service.require_credential(session, credential_id)
+    await credential_service.update_credential_value(session, settings, credential, payload.value)
+    await session.commit()
+    return CredentialRead.model_validate(credential)
+
+
+@router.delete("/credentials/{credential_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_credential(credential_id: uuid.UUID, session: SessionDep, _: ManageCred) -> None:
+    credential = await credential_service.require_credential(session, credential_id)
+    in_use = await session.scalar(
+        select(func.count())
+        .select_from(Repository)
+        .where(Repository.credential_id == credential_id)
+    )
+    if in_use:
+        raise ConflictError(f"该凭据正被 {in_use} 个仓库使用，无法删除")
+    await credential_service.delete_credential(session, credential)
+    await session.commit()
+
+
+# ---------------------------------------------------------------------------
+# 仓库
+# ---------------------------------------------------------------------------
+
+
+async def _decorate(session: SessionDep, repository: Repository) -> RepositoryRead:
+    data = RepositoryRead.model_validate(repository)
+    data.pull_count = await session.scalar(
+        select(func.count())
+        .select_from(PullRequest)
+        .where(PullRequest.repository_id == repository.id)
+    )
+    data.issue_count = await session.scalar(
+        select(func.count()).select_from(Issue).where(Issue.repository_id == repository.id)
+    )
+    if repository.webhook_secret:
+        data.webhook_path = f"/api/v1/webhooks/atomgit/{repository.webhook_secret}"
+    return data
+
+
+@router.get("/repositories", response_model=list[RepositoryRead])
+async def list_repositories(session: SessionDep, _: CurrentUserDep) -> list[RepositoryRead]:
+    repositories = await repository_service.list_repositories(session)
+    return [await _decorate(session, repo) for repo in repositories]
+
+
+@router.post("/repositories", response_model=RepositoryRead, status_code=status.HTTP_201_CREATED)
+async def create_repository(
+    payload: RepositoryCreate,
+    session: SessionDep,
+    settings: SettingsDep,
+    _: ManageRepo,
+) -> RepositoryRead:
+    repository = await repository_service.create_repository(
+        session,
+        settings,
+        owner=payload.owner,
+        name=payload.name,
+        credential_id=payload.credential_id,
+        display_name=payload.display_name,
+        api_base_url=payload.api_base_url,
+        tracked_branches=payload.tracked_branches,
+        backfill_days=payload.backfill_days,
+    )
+    await session.commit()
+    return await _decorate(session, repository)
+
+
+@router.get("/repositories/{repository_id}", response_model=RepositoryRead)
+async def get_repository(
+    repository_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> RepositoryRead:
+    repository = await repository_service.require_repository(session, repository_id)
+    return await _decorate(session, repository)
+
+
+@router.patch("/repositories/{repository_id}", response_model=RepositoryRead)
+async def update_repository(
+    repository_id: uuid.UUID,
+    payload: RepositoryUpdate,
+    session: SessionDep,
+    _: ManageRepo,
+) -> RepositoryRead:
+    repository = await repository_service.require_repository(session, repository_id)
+    await repository_service.update_repository(
+        session, repository, **payload.model_dump(exclude_unset=True)
+    )
+    await session.commit()
+    return await _decorate(session, repository)
+
+
+@router.post("/repositories/{repository_id}/rotate-webhook", response_model=RepositoryRead)
+async def rotate_webhook(
+    repository_id: uuid.UUID, session: SessionDep, _: ManageRepo
+) -> RepositoryRead:
+    repository = await repository_service.require_repository(session, repository_id)
+    await repository_service.rotate_webhook_secret(session, repository)
+    await session.commit()
+    return await _decorate(session, repository)
+
+
+# ---------------------------------------------------------------------------
+# 同步
+# ---------------------------------------------------------------------------
+
+
+@router.post("/repositories/{repository_id}/sync", response_model=list[SyncRunRead])
+async def trigger_sync(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    settings: SettingsDep,
+    _: ManageRepo,
+    detail_limit: Annotated[int, Query(ge=0, le=500)] = 50,
+) -> list[SyncRunRead]:
+    """手动触发一次完整同步。
+
+    同步在执行期间会持续占用连接，故此处同步等待完成再返回；
+    仓库规模较大时不适宜在请求内长时间阻塞，后续会迁到后台任务队列。
+    """
+    repository = await repository_service.require_repository(session, repository_id)
+    runs = await sync_service.sync_repository(
+        session, settings, repository, trigger=SyncTrigger.MANUAL, detail_limit=detail_limit
+    )
+    return [SyncRunRead.model_validate(run) for run in runs]
+
+
+@router.get("/repositories/{repository_id}/sync-runs", response_model=Page[SyncRunRead])
+async def list_sync_runs(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    page: Annotated[int, Query(ge=1)] = 1,
+    per_page: Annotated[int, Query(ge=1, le=100)] = 20,
+) -> Page[SyncRunRead]:
+    await repository_service.require_repository(session, repository_id)
+    total = await session.scalar(
+        select(func.count()).select_from(SyncRun).where(SyncRun.repository_id == repository_id)
+    )
+    stmt = (
+        select(SyncRun)
+        .where(SyncRun.repository_id == repository_id)
+        .order_by(SyncRun.started_at.desc())
+        .offset((page - 1) * per_page)
+        .limit(per_page)
+    )
+    runs = list((await session.scalars(stmt)).all())
+    return Page.create(
+        [SyncRunRead.model_validate(run) for run in runs], total or 0, page, per_page
+    )
+
+
+@router.get("/credentials/{credential_id}", response_model=CredentialRead)
+async def get_credential(
+    credential_id: uuid.UUID, session: SessionDep, _: ManageCred
+) -> CredentialRead:
+    credential: Credential = await credential_service.require_credential(session, credential_id)
+    return CredentialRead.model_validate(credential)
+
+
+@router.get("/repositories/{repository_id}/webhook", response_model=RepositoryRead)
+async def get_webhook_config(
+    repository_id: uuid.UUID, session: SessionDep, _: ManageRepo
+) -> RepositoryRead:
+    repository = await repository_service.require_repository(session, repository_id)
+    if not repository.webhook_secret:
+        raise NotFoundError("该仓库尚未生成 webhook 密钥")
+    return await _decorate(session, repository)

package/backend/app/api/v1/router.py

@@ -0,0 +1,32 @@
+"""v1 路由汇总。"""
+
+from fastapi import APIRouter
+
+from app.api.v1 import (
+    ai,
+    analytics,
+    attention,
+    auth,
+    classification,
+    health,
+    issues,
+    pulls,
+    repositories,
+    sig,
+    users,
+    webhooks,
+)
+
+router = APIRouter()
+router.include_router(health.router)
+router.include_router(auth.router)
+router.include_router(users.router)
+router.include_router(repositories.router)
+router.include_router(pulls.router)
+router.include_router(issues.router)
+router.include_router(classification.router)
+router.include_router(sig.router)
+router.include_router(attention.router)
+router.include_router(ai.router)
+router.include_router(analytics.router)
+router.include_router(webhooks.router)