add /api/{user}/{repository} endpoint and return openapi.json on all available options on /api and /api/

Author: ix-56h

src/server/main.py

@@ -7,7 +7,7 @@
 
 from dotenv import load_dotenv
 from fastapi import FastAPI, Request
-from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from slowapi.errors import RateLimitExceeded
 from starlette.middleware.trustedhost import TrustedHostMiddleware
@@ -100,10 +100,52 @@ async def llm_txt() -> FileResponse:
 
 @app.get("/docs", response_class=HTMLResponse)
 async def custom_swagger_ui(request: Request) -> HTMLResponse:
-    """Render the Swagger UI documentation page inside the Jinja theme."""
+    """Swagger UI documentation."""
     return templates.TemplateResponse("swagger_ui.jinja", {"request": request})
 
 
+@app.get("/api", include_in_schema=True)
+@app.get("/api/", include_in_schema=True)
+def openapi_json_get() -> JSONResponse:
+    """Return the OpenAPI schema (openapi.json)."""
+    return JSONResponse(app.openapi())
+
+
+@app.post("/api", include_in_schema=False)
+@app.post("/api/", include_in_schema=True)
+def openapi_json_post() -> JSONResponse:
+    """Return the OpenAPI schema (openapi.json)."""
+    return JSONResponse(app.openapi())
+
+
+@app.put("/api", include_in_schema=False)
+@app.put("/api/", include_in_schema=False)
+def openapi_json_put() -> JSONResponse:
+    """Return the OpenAPI schema (openapi.json)."""
+    return JSONResponse(app.openapi())
+
+
+@app.delete("/api", include_in_schema=False)
+@app.delete("/api/", include_in_schema=False)
+def openapi_json_delete() -> JSONResponse:
+    """Return the OpenAPI schema (openapi.json)."""
+    return JSONResponse(app.openapi())
+
+
+@app.options("/api", include_in_schema=False)
+@app.options("/api/", include_in_schema=False)
+def openapi_json_options() -> JSONResponse:
+    """Return the OpenAPI schema (openapi.json)."""
+    return JSONResponse(app.openapi())
+
+
+@app.head("/api", include_in_schema=False)
+@app.head("/api/", include_in_schema=False)
+def openapi_json_head() -> JSONResponse:
+    """Return the OpenAPI schema (openapi.json)."""
+    return JSONResponse(app.openapi())
+
+
 # Include routers for modular endpoints
 app.include_router(index)
 app.include_router(ingest)

src/server/models.py

@@ -99,13 +99,10 @@ class IngestErrorResponse(BaseModel):
     ----------
     error : str
         Error message describing what went wrong.
-    repo_url : str
-        The repository URL that failed to process.
 
     """
 
     error: str = Field(..., description="Error message")
-    repo_url: str = Field(..., description="Repository URL that failed")
 
 
 # Union type for API responses

src/server/query_processor.py

@@ -102,7 +102,7 @@ async def process_query(
             print(f"{Colors.BROWN}WARN{Colors.END}: {Colors.RED}<-  {Colors.END}", end="")
             print(f"{Colors.RED}{exc}{Colors.END}")
 
-        return IngestErrorResponse(error=str(exc), repo_url=short_repo_url)
+        return IngestErrorResponse(error=str(exc))
 
     if len(content) > MAX_DISPLAY_SIZE:
         content = (

src/server/routers/ingest.py

@@ -5,6 +5,7 @@
 
 from server.models import IngestErrorResponse, IngestRequest, IngestSuccessResponse
 from server.query_processor import process_query
+from server.server_config import DEFAULT_MAX_FILE_SIZE_KB
 from server.server_utils import limiter
 
 router = APIRouter()
@@ -64,7 +65,6 @@ async def api_ingest(
         # Handle validation errors with 400 status code
         error_response = IngestErrorResponse(
             error=f"Validation error: {ve!s}",
-            repo_url=ingest_request.input_text,
         )
         return JSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -75,7 +75,83 @@ async def api_ingest(
         # Handle unexpected errors with 500 status code
         error_response = IngestErrorResponse(
             error=f"Internal server error: {exc!s}",
-            repo_url=ingest_request.input_text,
+        )
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=error_response.model_dump(),
+        )
+
+
+@router.get(
+    "/api/{user}/{repository}",
+    responses={
+        status.HTTP_200_OK: {"model": IngestSuccessResponse, "description": "Successful ingestion"},
+        status.HTTP_400_BAD_REQUEST: {"model": IngestErrorResponse, "description": "Bad request or processing error"},
+        status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": IngestErrorResponse, "description": "Internal server error"},
+    },
+)
+@limiter.limit("10/minute")
+async def api_ingest_get(
+    request: Request,  # noqa: ARG001
+    user: str,
+    repository: str,
+    max_file_size: int = DEFAULT_MAX_FILE_SIZE_KB,
+    pattern_type: str = "exclude",
+    pattern: str = "",
+    token: str = "",
+) -> JSONResponse:
+    """Ingest a GitHub repository via GET and return processed content.
+
+    **This endpoint processes a GitHub repository by analyzing its structure and returning a summary**
+    with the repository's content. The response includes file tree structure, processed content, and
+    metadata about the ingestion. All ingestion parameters are optional and can be provided as query parameters.
+
+    **Path Parameters**
+    - **user** (`str`): GitHub username or organization
+    - **repository** (`str`): GitHub repository name
+
+    **Query Parameters**
+    - **max_file_size** (`int`, optional): Maximum file size to include in the digest (default: 50 KB)
+    - **pattern_type** (`str`, optional): Type of pattern to use ("include" or "exclude", default: "exclude")
+    - **pattern** (`str`, optional): Pattern to include or exclude in the query (default: "")
+    - **token** (`str`, optional): GitHub personal access token for private repositories (default: "")
+
+    **Returns**
+    - **JSONResponse**: Success response with ingestion results or error response with appropriate HTTP status code
+    """  # pylint: disable=unused-argument
+    try:
+        effective_input_text = f"{user}/{repository}"
+        result = await process_query(
+            input_text=effective_input_text,
+            slider_position=max_file_size,
+            pattern_type=pattern_type,
+            pattern=pattern,
+            token=token or None,
+        )
+
+        if isinstance(result, IngestErrorResponse):
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=result.model_dump(),
+            )
+
+        return JSONResponse(
+            status_code=status.HTTP_200_OK,
+            content=result.model_dump(),
+        )
+
+    except ValueError as ve:
+        error_response = IngestErrorResponse(
+            error=f"Validation error: {ve!s}",
+        )
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=error_response.model_dump(),
+        )
+
+    except Exception as exc:
+        error_response = IngestErrorResponse(
+            error=f"Internal server error: {exc!s}",
         )
         return JSONResponse(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,