core-runtime 0.1.1__py3-none-any.whl

api/v1/quality_routes.py

@@ -0,0 +1,272 @@
+# src/api/v1/quality_routes.py
+
+"""
+Quality API endpoints (ADR-055 Phase 2, D3).
+
+The /quality namespace divides into two execution models:
+
+* Synchronous (POST /quality/imports, POST /quality/body-ui) — fast
+  inline checks. The route awaits the backend, shapes the ADR-055 D3
+  response `{status, violations}`, returns 200. No fix_runs row.
+
+* Asynchronous (POST /quality/lint, POST /quality/tests,
+  POST /quality/system, POST /quality/gates) — subprocess-backed.
+  The route INSERTs a pending row in core.fix_runs (kind='quality_check',
+  fix_id=check_name), schedules execution on a background task, and
+  returns 202 with the run_id and a poll href pointing at
+  /v1/fix/runs/{id} — the /fix resource read endpoint serves
+  quality_check rows by design (single resource table, ADR-055 D1).
+
+CONSTITUTIONAL:
+- Session access via api.dependencies.get_api_session /
+  open_background_session only.
+- CoreContext is read from request.app.state.core_context.
+- body.* is reached through the will.governance.fix_runner facade —
+  no direct imports here (architecture.api.no_body_bypass).
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+from uuid import UUID
+
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    Body,
+    Depends,
+    Request,
+    Response,
+)
+from pydantic import BaseModel
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.dependencies import get_api_session, open_background_session
+from shared.context import CoreContext
+from shared.logger import getLogger
+from will.governance.fix_runner import (
+    run_and_persist_quality,
+    run_quality_body_ui,
+    run_quality_imports,
+    run_quality_policy_coverage,
+)
+
+
+logger = getLogger(__name__)
+
+
+router = APIRouter(prefix="/quality")
+
+
+# ID: 3b42b16d-03d5-4114-bbda-75965bf614ad
+class QualityTargetRequest(BaseModel):
+    """Body for the two synchronous /quality endpoints."""
+
+    target_files: list[str] | None = None
+
+
+# ID: 5d78bfbd-f21b-4918-b6ab-aee0ffbad1d2
+class QualityLintRequest(BaseModel):
+    """Body for POST /quality/lint."""
+
+    fix: bool = False
+    requested_by: str = "api"
+
+
+# ID: 22a0c461-1ed9-49e2-bf90-6012cbdfb1e8
+class QualityTestsRequest(BaseModel):
+    """Body for POST /quality/tests."""
+
+    path: str | None = None
+    requested_by: str = "api"
+
+
+# ID: 378fa29d-1b53-4277-81ef-9536b7204d2e
+class QualityAsyncRequest(BaseModel):
+    """Body for POST /quality/system and POST /quality/gates."""
+
+    requested_by: str = "api"
+
+
+# ID: 66a524c0-02ea-4e56-acb8-80ded84e3966
+async def _dispatch_quality(
+    *,
+    check: Literal["lint", "tests", "system", "gates"],
+    params: dict,
+    requested_by: str,
+    request: Request,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    session: AsyncSession,
+) -> dict:
+    """Shared body for the four async /quality endpoints.
+
+    Inserts a pending fix_runs row (kind='quality_check', fix_id=check)
+    and schedules run_and_persist_quality on a background task. The
+    response href points at /fix/runs/{id} — that endpoint serves
+    quality_check rows alongside atomic / flow / modularity rows.
+    """
+    core_context: CoreContext = request.app.state.core_context
+
+    result = await session.execute(
+        text(
+            """
+            INSERT INTO core.fix_runs
+                (kind, fix_id, write, status, requested_by)
+            VALUES ('quality_check', :check, FALSE, 'pending', :requested_by)
+            RETURNING id
+            """
+        ),
+        {"check": check, "requested_by": requested_by},
+    )
+    run_id: UUID = result.scalar_one()
+    await session.commit()
+
+    # ID: 6a26c22a-b5c9-4063-bcdc-f01077e9002d
+    async def drive_quality() -> None:
+        """Background task — owns its own session per ADR-053 lifecycle."""
+        async for bg_session in open_background_session():
+            await run_and_persist_quality(
+                core_context,
+                bg_session,
+                run_id=run_id,
+                check=check,
+                params=params,
+            )
+
+    background_tasks.add_task(drive_quality)
+
+    response.status_code = 202
+    return {
+        "run_id": str(run_id),
+        "status": "pending",
+        "href": f"/fix/runs/{run_id}",
+    }
+
+
+# ----------------------------------------------------------------------
+# Synchronous endpoints
+# ----------------------------------------------------------------------
+
+
+@router.post("/imports")
+# ID: 426c8ef0-3264-4e0d-9d6a-330bc46bbea3
+async def quality_imports(
+    payload: QualityTargetRequest = Body(default_factory=QualityTargetRequest),
+) -> dict:
+    """Run the import-resolution check inline. Returns {status, violations}."""
+    return await run_quality_imports(payload.target_files)
+
+
+@router.post("/body-ui")
+# ID: b9aea824-c569-4243-9eaf-4fc55b895202
+async def quality_body_ui(
+    request: Request,
+    payload: QualityTargetRequest = Body(default_factory=QualityTargetRequest),
+) -> dict:
+    """Run the Body-layer UI contract check inline. Returns {status, violations}."""
+    core_context: CoreContext = request.app.state.core_context
+    return await run_quality_body_ui(core_context, payload.target_files)
+
+
+@router.post("/policy-coverage")
+# ID: 7c1b5e8a-4f2d-49a6-b3e8-d1c4a2f6b9e0
+async def quality_policy_coverage(request: Request) -> dict:
+    """Run the constitutional policy-coverage audit inline.
+
+    Returns the flattened PolicyCoverageReport: {report_id,
+    generated_at_utc, repo_root, summary, records, exit_code}. Sync;
+    no fix_runs row.
+    """
+    core_context: CoreContext = request.app.state.core_context
+    return await run_quality_policy_coverage(core_context)
+
+
+# ----------------------------------------------------------------------
+# Asynchronous endpoints — fix_runs (kind='quality_check')
+# ----------------------------------------------------------------------
+
+
+@router.post("/lint")
+# ID: d410a899-05c7-4ba4-a36e-1e3bb56623ee
+async def quality_lint(
+    request: Request,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    payload: QualityLintRequest = Body(default_factory=QualityLintRequest),
+    session: AsyncSession = Depends(get_api_session),
+) -> dict:
+    """Dispatch ruff lint (optionally with --fix). Async."""
+    return await _dispatch_quality(
+        check="lint",
+        params={"fix": payload.fix},
+        requested_by=payload.requested_by,
+        request=request,
+        response=response,
+        background_tasks=background_tasks,
+        session=session,
+    )
+
+
+@router.post("/tests")
+# ID: f29522c9-b43e-48ff-bd9e-ce93d88ffe09
+async def quality_tests(
+    request: Request,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    payload: QualityTestsRequest = Body(default_factory=QualityTestsRequest),
+    session: AsyncSession = Depends(get_api_session),
+) -> dict:
+    """Dispatch pytest, optionally scoped to a path. Async."""
+    return await _dispatch_quality(
+        check="tests",
+        params={"path": payload.path},
+        requested_by=payload.requested_by,
+        request=request,
+        response=response,
+        background_tasks=background_tasks,
+        session=session,
+    )
+
+
+@router.post("/system")
+# ID: 8cd84f9d-a9eb-4c17-bc5c-eef650da7e7e
+async def quality_system(
+    request: Request,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    payload: QualityAsyncRequest = Body(default_factory=QualityAsyncRequest),
+    session: AsyncSession = Depends(get_api_session),
+) -> dict:
+    """Dispatch the lint + tests bundle. Async."""
+    return await _dispatch_quality(
+        check="system",
+        params={},
+        requested_by=payload.requested_by,
+        request=request,
+        response=response,
+        background_tasks=background_tasks,
+        session=session,
+    )
+
+
+@router.post("/gates")
+# ID: c8876c66-40b1-4d55-b81d-dc9d91558ccb
+async def quality_gates(
+    request: Request,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    payload: QualityAsyncRequest = Body(default_factory=QualityAsyncRequest),
+    session: AsyncSession = Depends(get_api_session),
+) -> dict:
+    """Dispatch the six-gate quality bundle (ruff/mypy/pytest/pip-audit/radon/vulture)."""
+    return await _dispatch_quality(
+        check="gates",
+        params={},
+        requested_by=payload.requested_by,
+        request=request,
+        response=response,
+        background_tasks=background_tasks,
+        session=session,
+    )

api/v1/refactor_routes.py

@@ -0,0 +1,225 @@
+# src/api/v1/refactor_routes.py
+
+"""
+Refactor API endpoints (ADR-057 Phase 3, D2).
+
+Two endpoint groups:
+
+* Read-only queries — GET /refactor/score, /refactor/candidates,
+  /refactor/stats, /refactor/threshold. Each returns synchronously.
+
+* Async dispatch — POST /refactor/autonomous. Inserts a pending row in
+  core.refactor_runs, schedules a background task on the
+  will.governance.refactor_runner facade, returns 202 with run_id +
+  poll href. GET /refactor/runs/{run_id} reads back the persisted row.
+
+CONSTITUTIONAL:
+- Session access via api.dependencies.get_api_session /
+  open_background_session only.
+- CoreContext is read from request.app.state.core_context.
+- mind.* / will.autonomy.* are reached through the
+  will.governance.refactor_runner facade — no direct imports here
+  (architecture.api.no_body_bypass).
+"""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    Body,
+    Depends,
+    HTTPException,
+    Query,
+    Request,
+    Response,
+)
+from pydantic import BaseModel
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.dependencies import get_api_session, open_background_session
+from shared.context import CoreContext
+from shared.logger import getLogger
+from will.governance.refactor_runner import (
+    get_refactor_candidates,
+    get_refactor_score,
+    get_refactor_stats,
+    get_refactor_threshold,
+    run_and_persist_refactor_autonomous,
+)
+
+
+logger = getLogger(__name__)
+
+
+router = APIRouter(prefix="/refactor")
+
+
+# ID: 3a7b9c5d-6e8f-4a0b-1c2d-3e4f5a6b7c8f
+class RunAutonomousRequest(BaseModel):
+    """Body for POST /refactor/autonomous.
+
+    `goal` is forwarded as the natural-language goal to the A3 loop.
+    `write=false` is the dry-run default (ADR-014 dev-phase discipline).
+    """
+
+    goal: str
+    write: bool = False
+    requested_by: str = "api"
+
+
+# ---------- GET endpoints -------------------------------------------------
+
+
+@router.get("/threshold")
+# ID: 4b8c0d6e-7f9a-4b1c-2d3e-4f5a6b7c8d9a
+async def refactor_threshold(request: Request) -> dict:
+    """Return the constitutional modularity threshold."""
+    core_context: CoreContext = request.app.state.core_context
+    repo_root = core_context.git_service.repo_path
+    return {"threshold": get_refactor_threshold(repo_root)}
+
+
+@router.get("/score")
+# ID: 5c9d1e7f-8a0b-4c2d-3e4f-5a6b7c8d9e0b
+async def refactor_score(
+    request: Request,
+    file: str = Query(..., min_length=1),
+) -> dict:
+    """Return the per-file modularity score for `file` (relative path).
+
+    Unknown / missing files resolve to 404; analyzable files return the
+    full details payload from the modularity engine.
+    """
+    core_context: CoreContext = request.app.state.core_context
+    repo_root = core_context.git_service.repo_path
+    payload = get_refactor_score(repo_root, file)
+    if not payload["found"]:
+        raise HTTPException(status_code=404, detail=f"File not found: {file}")
+    return payload
+
+
+@router.get("/candidates")
+# ID: 6d0e2f8a-9b1c-4d3e-4f5a-6b7c8d9e0f1c
+async def refactor_candidates(
+    request: Request,
+    min_score: float | None = Query(default=None, ge=0.0, le=200.0),
+    limit: int | None = Query(default=50, ge=1, le=500),
+) -> dict:
+    """Return files exceeding the modularity threshold, highest first."""
+    core_context: CoreContext = request.app.state.core_context
+    repo_root = core_context.git_service.repo_path
+    return get_refactor_candidates(repo_root, min_score=min_score, limit=limit)
+
+
+@router.get("/stats")
+# ID: 7e1f3a9b-0c2d-4e4f-5a6b-7c8d9e0f1a2d
+async def refactor_stats(request: Request) -> dict:
+    """Return aggregate modularity-score distribution."""
+    core_context: CoreContext = request.app.state.core_context
+    repo_root = core_context.git_service.repo_path
+    return get_refactor_stats(repo_root)
+
+
+# ---------- POST async autonomous ----------------------------------------
+
+
+@router.post("/autonomous")
+# ID: 8f2a4b0c-1d3e-4f5a-6b7c-8d9e0f1a2b3e
+async def run_refactor_autonomous(
+    request: Request,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    payload: RunAutonomousRequest = Body(...),
+    session: AsyncSession = Depends(get_api_session),
+) -> dict:
+    """Trigger the A3 autonomous refactor cycle.
+
+    Inserts a pending row in core.refactor_runs and queues background
+    execution. The cycle's proposals land on core.autonomous_proposals;
+    refactor_runs.result holds the captured proposal_ids.
+    """
+    core_context: CoreContext = request.app.state.core_context
+
+    result = await session.execute(
+        text(
+            """
+            INSERT INTO core.refactor_runs
+                (goal, write, status, requested_by)
+            VALUES (:goal, :write, 'pending', :requested_by)
+            RETURNING id
+            """
+        ),
+        {
+            "goal": payload.goal,
+            "write": payload.write,
+            "requested_by": payload.requested_by,
+        },
+    )
+    run_id: UUID = result.scalar_one()
+    await session.commit()
+
+    # ID: 9a3b5c1d-2e4f-4a6b-7c8d-9e0f1a2b3c4f
+    async def drive_autonomous() -> None:
+        async for bg_session in open_background_session():
+            await run_and_persist_refactor_autonomous(
+                core_context,
+                bg_session,
+                run_id=run_id,
+                goal=payload.goal,
+                write=payload.write,
+            )
+
+    background_tasks.add_task(drive_autonomous)
+
+    response.status_code = 202
+    return {
+        "run_id": str(run_id),
+        "status": "pending",
+        "href": f"/refactor/runs/{run_id}",
+    }
+
+
+@router.get("/runs/{run_id}")
+# ID: 0b4c6d2e-3f5a-4b7c-8d9e-0f1a2b3c4d50
+async def get_refactor_run(
+    run_id: UUID,
+    session: AsyncSession = Depends(get_api_session),
+) -> dict:
+    """Return a persisted refactor run by id, or 404 if unknown."""
+    result = await session.execute(
+        text(
+            """
+            SELECT id, goal, write, status,
+                   requested_by, requested_at, started_at, finished_at,
+                   result, error
+              FROM core.refactor_runs
+             WHERE id = :rid
+            """
+        ),
+        {"rid": run_id},
+    )
+    row = result.mappings().first()
+    if row is None:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Refactor run not found: {run_id}",
+        )
+
+    return {
+        "run_id": str(row["id"]),
+        "goal": row["goal"],
+        "write": row["write"],
+        "status": row["status"],
+        "requested_by": row["requested_by"],
+        "requested_at": (
+            row["requested_at"].isoformat() if row["requested_at"] else None
+        ),
+        "started_at": row["started_at"].isoformat() if row["started_at"] else None,
+        "finished_at": (row["finished_at"].isoformat() if row["finished_at"] else None),
+        "result": row["result"],
+        "error": row["error"],
+    }