from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from fastapi import Depends, FastAPI, HTTPException, Query
from .auth.deps import require_editor
from .auth.mcp_routes import router as mcp_keys_router
from .auth.middleware import SessionAuthMiddleware
from .auth.routes import router as auth_router
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.freshness import build_freshness_report_db
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",
)
app.add_middleware(SessionAuthMiddleware, settings_provider=get_settings)
app.include_router(auth_router)
app.include_router(mcp_keys_router)
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),
user=Depends(require_editor),
) -> 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]:
if settings.storage_backend == "db":
return build_freshness_report_db(Database.from_settings(settings))
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),
user=Depends(require_editor),
) -> 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),
user=Depends(require_editor),
) -> 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),
user=Depends(require_editor),
) -> 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,
}