Api Documentation Generator

---
name: api-documentation-generator
description: Generates OpenAPI/Swagger documentation from API route files. Use when working with REST APIs, Express routes, FastAPI endpoints, or when user requests API documentation.
allowed-tools: Read, Grep, Glob, Write, Edit
---

# API Documentation Generator

This skill automatically generates OpenAPI 3.0 (Swagger) documentation from API route files in your codebase.

## When to Use This Skill

- User asks to generate API documentation
- Working with REST API endpoints
- Need to create or update OpenAPI/Swagger specs
- Setting up API documentation for Express, FastAPI, Flask, NestJS, or similar frameworks

## Instructions

### 1. Discover API Routes

Search the codebase for API route definitions:

- **Express/Node.js**: Look for `app.get()`, `app.post()`, `router.get()`, etc.
- **FastAPI/Python**: Look for `@app.get()`, `@router.post()`, decorators
- **Flask**: Look for `@app.route()` decorators
- **NestJS**: Look for `@Get()`, `@Post()`, `@Controller()` decorators
- **Rails**: Look for routes in `config/routes.rb`

Use Glob to find route files (e.g., `**/*routes*.{js,ts,py}`, `**/controllers/**/*.{js,ts}`)

### 2. Analyze Route Patterns

For each discovered route, extract:

- **HTTP Method**: GET, POST, PUT, PATCH, DELETE
- **Path**: The endpoint URL (e.g., `/api/users/:id`)
- **Parameters**: Path params, query params, request body
- **Response**: Expected response structure
- **Authentication**: Whether auth is required
- **Description**: Comments or docstrings near the route

### 3. Generate OpenAPI Specification

Create or update an OpenAPI 3.0 specification file (typically `openapi.yaml` or `swagger.json`):

- Start with the template from `templates/openapi-3.0.yaml`
- Map each route to an OpenAPI path object
- Define request/response schemas using JSON Schema
- Include parameter definitions (path, query, body)
- Add authentication schemes if detected (Bearer, API Key, OAuth2)
- Group endpoints by tags (e.g., "Users", "Products", "Auth")

### 4. Validate Completeness

Check that the generated documentation includes:

- All discovered endpoints
- Accurate HTTP methods and paths
- Request/response examples where possible
- Error responses (400, 401, 404, 500, etc.)
- Security requirements

### 5. Output Location

- Save as `openapi.yaml` in the project root, or
- Place in `docs/` or `api/` directory if those exist
- Ask user for preferred location if unclear

## Framework-Specific Notes

### Express/Node.js
- Check for route middleware that might affect auth/validation
- Look for request validators (Joi, express-validator, etc.)
- Extract JSDoc comments for endpoint descriptions

### FastAPI
- FastAPI auto-generates OpenAPI docs, but this skill can enhance them
- Extract Pydantic models for request/response schemas
- Check for `response_model` and `status_code` parameters

### NestJS
- Look for DTOs (Data Transfer Objects) for schemas
- Check for Swagger decorators (`@ApiOperation`, `@ApiResponse`)
- Extract metadata from controller and method decorators

## Best Practices

1. **Use existing schemas**: If the codebase has TypeScript interfaces, Pydantic models, or similar, use them for accurate schemas
2. **Include examples**: Add request/response examples from tests if available
3. **Group logically**: Organize endpoints by resource or feature area using tags
4. **Version appropriately**: Use the API version from the codebase (e.g., "1.0.0")
5. **Add descriptions**: Use code comments/docstrings for endpoint descriptions

## Supporting Files

- `templates/openapi-3.0.yaml`: Base OpenAPI template
- `examples.md`: Framework-specific examples