Newer
Older
gnexus-book / server / app / main.py
from __future__ import annotations

from datetime import UTC, datetime
from typing import Any

from fastapi import Depends, FastAPI, HTTPException, Query

from .config import Settings, get_settings
from .docs_repository import RepositoryError
from .freshness import build_freshness_report
from .git_adapter import CommitRequest, GitAdapter, GitAdapterError
from .inventory import InventoryError
from .pending_changes import PendingChangeError, ProposedChangeRequest
from .relationships import build_relationships
from .storage.db import Database
from .storage.documents import (
    DocumentError,
    diff_document_versions,
    get_document_version,
    list_document_versions,
    restore_document_version,
)
from .storage.factory import (
    make_docs_repository,
    make_inventory_repository,
    make_pending_change_repository,
)
from .storage.protocols import (
    DocsRepositoryProtocol,
    InventoryRepositoryProtocol,
    PendingChangeRepositoryProtocol,
)
from .storage.validation import validate_database
from .validation import validate_repository


app = FastAPI(
    title="Gnexus Book Server",
    version="0.1.0",
    description="Documentation, inventory, validation, and maintenance API for Gnexus Book.",
    docs_url="/api-docs",
    swagger_ui_oauth2_redirect_url="/api-docs/oauth2-redirect",
    redoc_url="/api-redoc",
)


def get_docs_repo(settings: Settings = Depends(get_settings)) -> DocsRepositoryProtocol:
    return make_docs_repository(settings)


def get_inventory_repo(settings: Settings = Depends(get_settings)) -> InventoryRepositoryProtocol:
    return make_inventory_repository(settings)


def get_pending_change_repo(
    settings: Settings = Depends(get_settings),
) -> PendingChangeRepositoryProtocol:
    return make_pending_change_repository(settings, via="api")


def get_git_adapter(settings: Settings = Depends(get_settings)) -> GitAdapter:
    return GitAdapter(settings)


@app.get("/health")
def health(settings: Settings = Depends(get_settings)) -> dict[str, Any]:
    payload: dict[str, Any] = {
        "status": "ok",
        "service": "gnexus-book",
        "version": app.version,
        "storage": settings.storage_backend,
        "timestamp": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
    }
    if settings.storage_backend == "db":
        try:
            Database.from_settings(settings).ping()
            payload["checks"] = {"db": {"status": "ok"}}
        except Exception:
            payload["status"] = "down"
            payload["checks"] = {"db": {"status": "down", "detail": "database unavailable"}}
    return payload


@app.get("/docs")
def list_docs(repo: DocsRepositoryProtocol = Depends(get_docs_repo)) -> list[dict[str, object]]:
    return repo.list_docs()


@app.get("/docs/read")
def read_doc(path: str = Query(...), repo: DocsRepositoryProtocol = Depends(get_docs_repo)) -> dict[str, object]:
    try:
        return repo.read_doc(path)
    except RepositoryError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@app.get("/search")
def search(q: str = Query(...), repo: DocsRepositoryProtocol = Depends(get_docs_repo)) -> list[dict[str, object]]:
    return repo.search(q)


@app.get("/documents/{path:path}/history")
def document_history(
    path: str, settings: Settings = Depends(get_settings)
) -> list[dict[str, object]]:
    if settings.storage_backend != "db":
        raise HTTPException(status_code=400, detail="Document history is available in database mode")
    try:
        return list_document_versions(Database.from_settings(settings), path)
    except DocumentError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@app.get("/documents/{path:path}/versions/{version_no}")
def document_version(
    path: str, version_no: int, settings: Settings = Depends(get_settings)
) -> dict[str, object]:
    if settings.storage_backend != "db":
        raise HTTPException(status_code=400, detail="Document versions are available in database mode")
    try:
        return get_document_version(Database.from_settings(settings), path, version_no)
    except DocumentError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@app.get("/documents/{path:path}/diff")
def document_diff(
    path: str,
    from_version: int | None = Query(default=None, alias="from"),
    to_version: int | None = Query(default=None, alias="to"),
    settings: Settings = Depends(get_settings),
) -> dict[str, object]:
    if settings.storage_backend != "db":
        raise HTTPException(status_code=400, detail="Document diff is available in database mode")
    try:
        return diff_document_versions(
            Database.from_settings(settings), path, from_version, to_version
        )
    except DocumentError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@app.post("/documents/{path:path}/restore/{version_no}")
def document_restore(
    path: str,
    version_no: int,
    summary: str | None = Query(default=None),
    settings: Settings = Depends(get_settings),
) -> dict[str, object]:
    if settings.storage_backend != "db":
        raise HTTPException(status_code=400, detail="Document restore is available in database mode")
    try:
        return restore_document_version(
            Database.from_settings(settings),
            settings,
            path,
            version_no,
            summary=summary,
            via="api",
        )
    except DocumentError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    except PendingChangeError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc


@app.get("/inventory")
def list_inventory_types(repo: InventoryRepositoryProtocol = Depends(get_inventory_repo)) -> list[str]:
    return repo.list_types()


@app.get("/inventory/{inventory_type}")
def read_inventory(
    inventory_type: str,
    raw: bool = False,
    repo: InventoryRepositoryProtocol = Depends(get_inventory_repo),
) -> object:
    try:
        if raw:
            return {"type": inventory_type, "raw": repo.read_raw(inventory_type)}
        return repo.read_parsed(inventory_type)
    except InventoryError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@app.get("/inventory/{inventory_type}/{item_id}")
def read_inventory_item(
    inventory_type: str,
    item_id: str,
    repo: InventoryRepositoryProtocol = Depends(get_inventory_repo),
) -> dict[str, object]:
    try:
        return repo.read_item(inventory_type, item_id)
    except InventoryError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@app.get("/traffic-routes")
def read_traffic_routes(repo: InventoryRepositoryProtocol = Depends(get_inventory_repo)) -> object:
    try:
        return repo.read_parsed("traffic-routes")
    except InventoryError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@app.get("/relationships")
def relationships(repo: InventoryRepositoryProtocol = Depends(get_inventory_repo)) -> dict[str, object]:
    try:
        return build_relationships(repo)
    except InventoryError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc


@app.get("/health/freshness")
def freshness(settings: Settings = Depends(get_settings)) -> dict[str, object]:
    return build_freshness_report(settings)


@app.get("/validate")
def validate(settings: Settings = Depends(get_settings)) -> dict[str, object]:
    if settings.storage_backend == "db":
        return validate_database(Database.from_settings(settings))
    return validate_repository(settings)


@app.get("/changes")
def list_changes(
    repo: PendingChangeRepositoryProtocol = Depends(get_pending_change_repo),
) -> list[dict[str, object]]:
    return repo.list()


@app.get("/changes/{change_id}")
def read_change(
    change_id: str,
    repo: PendingChangeRepositoryProtocol = Depends(get_pending_change_repo),
) -> dict[str, object]:
    try:
        return repo.get(change_id)
    except PendingChangeError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@app.post("/changes")
def propose_change(
    request: ProposedChangeRequest,
    repo: PendingChangeRepositoryProtocol = Depends(get_pending_change_repo),
) -> dict[str, object]:
    return repo.create(request)


@app.post("/changes/{change_id}/apply")
def apply_change(
    change_id: str,
    repo: PendingChangeRepositoryProtocol = Depends(get_pending_change_repo),
) -> dict[str, object]:
    try:
        return repo.apply(change_id)
    except PendingChangeError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc


@app.get("/git/status")
def git_status(git: GitAdapter = Depends(get_git_adapter)) -> dict[str, object]:
    try:
        return git.status()
    except GitAdapterError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc


@app.get("/git/diff")
def git_diff(files: list[str] | None = Query(default=None), git: GitAdapter = Depends(get_git_adapter)) -> dict[str, str]:
    try:
        return git.diff(files)
    except GitAdapterError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc


@app.post("/commit")
def commit(request: CommitRequest, git: GitAdapter = Depends(get_git_adapter)) -> dict[str, object]:
    try:
        return git.commit(request)
    except GitAdapterError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc


@app.get("/mcp/info")
def mcp_info() -> dict[str, Any]:
    from .mcp_server import mcp
    tools = [
        {"name": t.name, "description": t.description}
        for t in mcp._tool_manager.list_tools()
    ]
    return {
        "name": mcp.name,
        "instructions": mcp.instructions,
        "tools": tools,
    }