Docuccino

Documentation from your code, not from annotations

Point Docuccino at your routes and it reads your controllers, form requests, resources, DTOs, enums, and exception handling to produce an accurate OpenAPI 3.2 document — then serves it in a built-in interactive viewer. You add annotations only where you want to say something your code can’t.

Under the hood, Docuccino builds a UIR (Universal Intermediate Representation): an OpenAPI-shaped document that also carries a stable identity for every operation and schema, and a record of where each detail came from. That’s what powers the deterministic output and the semantic diff.

A few commands

Where do your docs need to be readable? Pick the tab that matches:

Serve docs from your app

composer require docuccino/laravel
composer require --dev docuccino/inference-phpstan
php artisan docuccino:export

Readers hit /docs/api on a deployed environment: the adapter ships to production and serves the committed artifact, while the analysis engine stays a dev dependency.

Docs in development only

composer require --dev docuccino/laravel docuccino/inference-phpstan
php artisan docuccino:export

Read the docs locally, ship nothing: composer install --no-dev puts neither package in your production vendor/.

Host the spec elsewhere

composer require --dev docuccino/laravel docuccino/inference-phpstan
php artisan docuccino:export --out=build/openapi.json

Export in CI and upload the artifact to whichever documentation host you use. Both packages stay dev-only, because your app never serves the docs.

Your OpenAPI document lands where you point it, and the bundled viewer is live at /docs/api in your local environment. Nothing else to configure — installation walks through it properly.

What you get

Deep type inference

Response and request shapes are inferred from your real types — array shapes, generics, and conditional returns included. Your existing type hints and PHPStan extensions make your docs better automatically.

Query parameters, for free

Filters, sorts, includes, and pagination for list endpoints are detected from your code — even when the query is built several method calls deep. No hand-written parameter lists to maintain.

Error responses, automatically

Docuccino reads your actual exception handling — render callbacks, exception render(), Responsable::toResponse() — so 422, 404, 403, and your custom error shapes are documented with zero configuration.

Deterministic output

The same code always produces byte-for-byte identical output — no timestamps, no absolute paths, no shuffling. Commit the file and your diffs stay clean; a tool upgrade moves at most a single generator version line (and nothing at all in the OpenAPI export).

A diff you can gate CI on

docuccino:diff --enforce compares two versions of your API and enforces a versioning policy. Ship a breaking change without the right version bump and the build fails.

A format you can build on

The UIR is a documented format with a published JSON Schema. Export it with docuccino:export --format=uir, validate it with docuccino:validate, and read every detail’s provenance — the same document the emitters and the diff run on.

See it rendered

A small invoices API in the shape Docuccino emits, rendered by the bundled Scalar viewer — the same viewer your app serves at /docs/api. No screenshots: this is the live component reading an OpenAPI 3.1 document.

Docuccino documents Laravel applications today. Everything downstream of route analysis — the UIR, the emitters, the diff, the lint — is framework-agnostic, so an adapter for another framework plugs into machinery that already exists.

Start here

InstallationInstall the package and export your first document.

Documenting your APIWhat Docuccino reads, package by package and concern by concern.

Configuration referenceEvery option in config/docuccino.php, with its default.

Attributes referenceFine-tune the output when the code can't say it all.