@kernel-sig/console 0.1.0

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

@@ -0,0 +1,192 @@
+"""分类 API。
+
+分类结果对 PR/Issue 是同一件事，因此接口按 subject_type 区分而非拆两套。
+唯一需要人工介入的操作是「覆盖」—— 自动分类出错时，维护者改一次就该定下来。
+"""
+
+import uuid
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Query
+
+from app.api.deps import CurrentUserDep, SessionDep, require_permission
+from app.core.exceptions import NotFoundError
+from app.core.permissions import Permission
+from app.models.classification import Classification, ClassificationSource, PRKind, SubjectType
+from app.models.pull_request import PullRequest
+from app.schemas.classification import (
+    ClassificationOverride,
+    ClassificationRead,
+    KindCount,
+    SubsystemCount,
+)
+from app.schemas.common import MessageResponse, Page
+from app.services import classification_service, repository_service
+
+router = APIRouter(tags=["classification"])
+
+Classify = Annotated[object, Depends(require_permission(Permission.CLASSIFY))]
+
+
+@router.get(
+    "/repositories/{repository_id}/classifications", response_model=Page[ClassificationRead]
+)
+async def list_classifications(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    subject_type: SubjectType | None = None,
+    kind: PRKind | None = None,
+    subsystem: str | None = None,
+    source: ClassificationSource | None = None,
+    override_only: bool = False,
+    page: Annotated[int, Query(ge=1)] = 1,
+    per_page: Annotated[int, Query(ge=1, le=200)] = 50,
+) -> Page[ClassificationRead]:
+    await repository_service.require_repository(session, repository_id)
+    rows, total = await classification_service.list_classifications(
+        session,
+        repository_id=repository_id,
+        subject_type=subject_type,
+        kind=kind,
+        subsystem=subsystem,
+        source=source,
+        override_only=override_only,
+        limit=per_page,
+        offset=(page - 1) * per_page,
+    )
+    return Page.create(
+        [ClassificationRead.model_validate(row) for row in rows], total, page, per_page
+    )
+
+
+@router.get("/repositories/{repository_id}/classifications/kinds", response_model=list[KindCount])
+async def kind_distribution(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    subject_type: SubjectType = SubjectType.PULL_REQUEST,
+) -> list[KindCount]:
+    """按类型计数，供筛选栏与统计图直接渲染。"""
+    await repository_service.require_repository(session, repository_id)
+    rows = await classification_service.kind_distribution(
+        session, repository_id, subject_type=subject_type
+    )
+    return [KindCount(**row) for row in rows]
+
+
+@router.get(
+    "/repositories/{repository_id}/classifications/subsystems",
+    response_model=list[SubsystemCount],
+)
+async def subsystem_distribution(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    limit: Annotated[int, Query(ge=1, le=60)] = 15,
+) -> list[SubsystemCount]:
+    """按子系统计数。未归类的单列会让这张表失去意义，故不计入。"""
+    await repository_service.require_repository(session, repository_id)
+    rows = await classification_service.subsystem_distribution(session, repository_id, limit=limit)
+    return [SubsystemCount(**row) for row in rows]
+
+
+@router.get("/pulls/{pull_id}/classification", response_model=ClassificationRead | None)
+async def pull_classification(
+    pull_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> ClassificationRead | None:
+    """单个 PR 的分类结果。
+
+    详情页拿到的只有 PR id，没有仓库 id，而按仓库列出全部分类再筛
+    既浪费又要在前端拼分页。详情页需要的就是"这一条是什么"。
+    未分类时返回 null 而非 404 —— "尚未分类"是正常状态，不是错误。
+    """
+    pull = await session.get(PullRequest, pull_id)
+    if pull is None:
+        raise NotFoundError("PR 不存在", resource="pull_request", identifier=str(pull_id))
+
+    item = await classification_service.get_classification(
+        session, SubjectType.PULL_REQUEST, pull_id
+    )
+    return ClassificationRead.model_validate(item) if item is not None else None
+
+
+@router.post("/repositories/{repository_id}/classifications/recompute")
+async def recompute_classifications(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: Classify,
+) -> MessageResponse:
+    """按规则重算全部活动 PR/Issue 的分类。
+
+    只影响规则与 AI 的判定结果，人工覆盖过的记录原样保留。
+    """
+    from sqlalchemy import select as sa_select
+
+    from app.models.issue import Issue
+
+    repository = await repository_service.require_repository(session, repository_id)
+    # 覆盖全部状态：合入/关闭的 PR 也参与版本合入统计，
+    # 只按 open 分类会让月度汇总的类别分布几乎全是 unknown。
+    pulls = list(
+        (
+            await session.scalars(
+                sa_select(PullRequest).where(PullRequest.repository_id == repository.id)
+            )
+        ).all()
+    )
+    issues = list(
+        (
+            await session.scalars(
+                sa_select(Issue).where(Issue.repository_id == repository.id)
+            )
+        ).all()
+    )
+
+    by_kind = await classification_service.classify_pulls(session, repository, pulls)
+    by_kind += await classification_service.classify_issues(session, repository, issues)
+    await session.commit()
+    return MessageResponse(message=f"已重算 {by_kind} 条分类（人工覆盖的未被改动）")
+
+
+async def _require_classification(session: SessionDep, classification_id: uuid.UUID):
+    item = await session.get(Classification, classification_id)
+    if item is None:
+        raise NotFoundError(
+            "分类记录不存在", resource="classification", identifier=str(classification_id)
+        )
+    return item
+
+
+@router.put("/classifications/{classification_id}", response_model=ClassificationRead)
+async def override_classification(
+    classification_id: uuid.UUID,
+    payload: ClassificationOverride,
+    session: SessionDep,
+    user: CurrentUserDep,
+    _: Classify,
+) -> ClassificationRead:
+    """人工指定分类。
+
+    这是唯一能让某条记录"定格"的操作：此后规则重算与 AI 补判都不会改写它。
+    没有这条路径，维护者纠正过一次又被改回去，就不会再信任自动分类。
+    """
+    item = await _require_classification(session, classification_id)
+    await classification_service.override(
+        session, item, kind=payload.kind, subsystem=payload.subsystem, user_id=user.id
+    )
+    await session.commit()
+    return ClassificationRead.model_validate(item)
+
+
+@router.delete("/classifications/{classification_id}/override", response_model=ClassificationRead)
+async def clear_classification_override(
+    classification_id: uuid.UUID,
+    session: SessionDep,
+    _: Classify,
+) -> ClassificationRead:
+    """撤销人工覆盖，交还给自动分类。下次重算会重新判定。"""
+    item = await _require_classification(session, classification_id)
+    await classification_service.clear_override(session, item)
+    await session.commit()
+    return ClassificationRead.model_validate(item)

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

@@ -0,0 +1,29 @@
+"""健康检查。"""
+
+from fastapi import APIRouter, Response, status
+from sqlalchemy import text
+
+from app.api.deps import SessionDep
+
+router = APIRouter(tags=["health"])
+
+
+@router.get("/healthz", summary="存活检查")
+async def healthz() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@router.get("/readyz", summary="就绪检查（含依赖连通性）")
+async def readyz(session: SessionDep, response: Response) -> dict[str, object]:
+    checks: dict[str, str] = {}
+
+    try:
+        await session.execute(text("SELECT 1"))
+        checks["database"] = "ok"
+    except Exception as exc:
+        checks["database"] = f"error: {exc}"
+
+    healthy = all(v == "ok" for v in checks.values())
+    if not healthy:
+        response.status_code = status.HTTP_503_SERVICE_UNAVAILABLE
+    return {"status": "ok" if healthy else "degraded", "checks": checks}

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

@@ -0,0 +1,143 @@
+"""Issue API。"""
+
+import uuid
+from typing import Annotated, Literal
+
+from fastapi import APIRouter, Query
+from sqlalchemy import Select, String, cast, func, or_, select
+
+from app.api.deps import CurrentUserDep, SessionDep
+from app.core.exceptions import NotFoundError
+from app.models.classification import Classification, PRKind, SubjectType
+from app.models.issue import Issue
+from app.schemas.common import Page
+from app.schemas.pull_request import IssueDetail, IssueListItem, IssueSummary
+from app.services import classification_service, repository_service
+
+router = APIRouter(tags=["issues"])
+
+IssueSort = Literal["updated", "created", "comments"]
+
+
+def _base_query(repository_id: uuid.UUID) -> Select:
+    return select(Issue).where(Issue.repository_id == repository_id)
+
+
+@router.get("/repositories/{repository_id}/issues", response_model=Page[IssueListItem])
+async def list_issues(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    state: Annotated[str | None, Query(pattern="^(open|closed|all)$")] = "open",
+    issue_type: str | None = None,
+    kind: Annotated[list[PRKind] | None, Query()] = None,
+    priority: str | None = None,
+    author: str | None = None,
+    assignee: str | None = None,
+    label: str | None = None,
+    q: str | None = None,
+    sort: IssueSort = "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[IssueListItem]:
+    await repository_service.require_repository(session, repository_id)
+
+    stmt = _base_query(repository_id)
+    if state and state != "all":
+        stmt = stmt.where(Issue.state == state)
+    if issue_type:
+        stmt = stmt.where(Issue.issue_type == issue_type)
+    if kind:
+        # 半连接：Issue 与分类一对一，JOIN 不改变行数却要引入列名限定
+        stmt = stmt.where(
+            Issue.id.in_(
+                select(Classification.subject_id).where(
+                    Classification.subject_type == SubjectType.ISSUE,
+                    Classification.kind.in_(kind),
+                )
+            )
+        )
+    if priority:
+        stmt = stmt.where(Issue.priority_label == priority)
+    if author:
+        stmt = stmt.where(Issue.author_login == author)
+    if assignee:
+        stmt = stmt.where(Issue.assignee_login == assignee)
+    if label:
+        stmt = stmt.where(Issue.label_names.contains([label]))
+    if q:
+        pattern = f"%{q}%"
+        stmt = stmt.where(
+            or_(
+                Issue.title.ilike(pattern),
+                cast(Issue.number, String).ilike(pattern),
+            )
+        )
+
+    total = await session.scalar(select(func.count()).select_from(stmt.subquery())) or 0
+
+    columns = {
+        "updated": Issue.atomgit_updated_at,
+        "created": Issue.atomgit_created_at,
+        "comments": Issue.comments_count,
+    }
+    column = columns[sort]
+    stmt = (
+        stmt.order_by(column.asc() if order == "asc" else column.desc(), Issue.number.desc())
+        .offset((page - 1) * per_page)
+        .limit(per_page)
+    )
+
+    rows = (await session.scalars(stmt)).all()
+    rows = list(rows)
+    # 一次性取回本页分类：Issue 有 2000+ 条，逐条查会拖垮列表
+    classified = await classification_service.classifications_for(
+        session, SubjectType.ISSUE, [row.id for row in rows]
+    )
+    items = [
+        IssueListItem(
+            **IssueSummary.model_validate(row).model_dump(),
+            kind=classified[row.id].kind if row.id in classified else None,
+        )
+        for row in rows
+    ]
+    return Page.create(items, total, page, per_page)
+
+
+@router.get("/issues/{issue_id}", response_model=IssueDetail)
+async def get_issue(issue_id: uuid.UUID, session: SessionDep, _: CurrentUserDep) -> IssueDetail:
+    issue = await session.get(Issue, issue_id)
+    if issue is None:
+        raise NotFoundError("Issue 不存在", resource="issue", identifier=str(issue_id))
+    detail = IssueDetail.model_validate(issue)
+    detail.body = issue.body
+    detail.finished_at = issue.finished_at
+    return detail
+
+
+@router.get("/repositories/{repository_id}/issues/facets")
+async def issue_facets(
+    repository_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> dict[str, list[dict]]:
+    """筛选项取值分布，供前端渲染下拉与计数。
+
+    使用 AtomGit 原生的 issue_type / priority 字段，
+    而非从标签猜测 —— 原生字段比标签更可靠。
+    """
+    await repository_service.require_repository(session, repository_id)
+
+    async def group_by(column) -> list[dict]:
+        stmt = (
+            select(column, func.count())
+            .where(Issue.repository_id == repository_id, column.is_not(None))
+            .group_by(column)
+            .order_by(func.count().desc())
+        )
+        return [{"value": row[0], "count": row[1]} for row in (await session.execute(stmt)).all()]
+
+    return {
+        "types": await group_by(Issue.issue_type),
+        "priorities": await group_by(Issue.priority_label),
+        "states": await group_by(Issue.issue_state),
+    }