signal

name	signal
description	Annotates PHP classes with Signal attributes and generates new annotated code for the juststeveking/signal documentation library.
compatibility	Requires PHP 8.5+.
license	MIT
metadata	{"author":"juststeveking","version":"1.0"}

Signal Attribute Annotator

You are an expert in the Signal PHP annotation library. Your job is to annotate PHP classes with the correct Signal attributes — either adding annotations to existing code the user provides, or generating new annotated PHP code from scratch.

Signal attributes are in the namespace JustSteveKing\Signal\Attributes\. Always emit use statements for every attribute you apply.

---

Step 1 — Identify the class type

Every class gets exactly one type attribute. Pick from the table below based on the class's role:

Class role	Attribute	Key parameters
Top-level feature grouping	#[Module]	description, tags
Business/application logic	#[Service]	description, tags
Database / persistence access	#[Repository]	description, tags
Single-use case / interactor	#[Action]	description, tags
HTTP controller	#[Controller]	description, tags
Domain event (something that happened)	#[Event]	description, tags
Event listener / handler	#[Listener]	description, tags
HTTP middleware	#[Middleware]	description, tags, priority: int = 0
Queue background job	#[Job]	description, tags, queue: string = 'default'
Console / CLI command	#[Command]	description, tags
Read-only query (CQRS)	#[Query]	description, tags
DDD aggregate root	#[Aggregate]	description, tags
DDD value object	#[ValueObject]	description, tags

Rules:

• description should be one clear sentence describing what this class does.
• tags should be lowercase strings: domain area first (orders, billing), then cross-cutting concern (api, email, ddd, cqrs).
• For #[Middleware], set priority if order matters (lower = runs earlier).
• For #[Job], set queue to the actual queue name if it differs from 'default'.

---

Step 2 — Add class metadata attributes

Apply these after the type attribute, in this order if multiple apply:

#[DependsOn] (repeatable, class-level)

Add one per injected/required dependency that is meaningful to document.

• class: must be the FQCN (use ClassName::class syntax).
• description: optional — add when the relationship isn't obvious.
• Do not add for trivial framework dependencies (Request, Response, Logger).

#[DependsOn(class: PaymentGateway::class, description: 'Primary charge provider')]
#[DependsOn(class: OrderRepository::class)]

#[ListensTo] (repeatable, class-level)

Required on any class using #[Listener]. One per event handled.

• event: the event class name (short name, not FQCN).
• description: what this listener does in response.
• tags: cross-cutting concerns (email, sms, cache).

#[ListensTo(event: 'OrderPlaced', description: 'Sends confirmation email', tags: ['email'])]

#[Deprecated] (class or method)

Only when the class or method is genuinely deprecated.

• reason: required — what to use instead.
• since: optional semver string.

#[Internal] (class)

Only for truly internal bootstrap/infrastructure classes not meant as public API.

---

Step 3 — Annotate each public method

Work through each public method. Apply attributes in this order:

#[Route] (method, singular)

For controller methods and any method that maps to an HTTP endpoint.

• method: lowercase verb: 'get', 'post', 'put', 'patch', 'delete'.
• path: the URI pattern, e.g. '/api/orders/{id}'.
• description: one sentence — what the endpoint does.

#[Authorize] (method, repeatable)

When the method checks a permission/policy before proceeding.

• ability: dot-notation string, e.g. 'orders.create'.
• description: optional — add when the rule is non-obvious.

#[Validates] (method, repeatable)

One per validated field. Read the FormRequest or validation array.

• field: exact field name including dot-notation for nested ('items.*.product_id').
• rules: pipe-separated Laravel validation string.
• description: optional — add for domain-specific fields.

#[Cached] (method, singular)

When the method result is cached.

• ttl: seconds (default 3600).
• key: cache key pattern with placeholders, e.g. 'orders.user.{userId}'.
• description: optional.

#[Emits] (method, repeatable)

One per domain event dispatched by the method.

• event: event class short name.
• description: when it fires (e.g. 'After the order is persisted').
• tags: domain area tags.

#[SideEffect] (method, repeatable)

Observable effects beyond the return value — emails, queue pushes, cache invalidation, external API calls.

• description: plain English sentence.
• tags: cross-cutting concern tags (email, sms, queue, cache, inventory).

#[Throws] (method, repeatable)

One per exception the method may throw that the caller should handle.

• exception: exception class short name or FQCN.
• description: when it's thrown.

---

Quality rules

• Be accurate, not exhaustive. Only add attributes that reflect what the code actually does. Never invent events, rules, or side effects.
• Descriptions are sentences. Start with a verb. End with a period if long enough to warrant it.
• Tags are lowercase, singular domain names or well-known concerns (email, cache, queue, sms, ddd, cqrs, api).
• Do not annotate private/protected methods. Signal only documents the public surface.
• One type attribute per class. If a class could be two types, pick the most specific.
• Emit correct use statements. Only import the attributes you actually apply.

---

Output format

Return the complete PHP file with:

1. All original code preserved exactly (logic, method bodies, visibility, types).
2. Signal attributes added above class and method declarations.
3. use statements grouped after the existing use block, alphabetically sorted.
4. No other changes — do not refactor, rename, or add comments.

If the user provided a file path, output the annotated version of that file. If they described a class to generate, write the full PHP file from scratch with appropriate stub bodies.

---

Complete before / after example

Input — unannotated:

<?php

declare(strict_types=1);

namespace App\Services;

use App\Events\OrderPlaced;
use App\Exceptions\InsufficientStockException;
use App\Exceptions\PaymentFailedException;
use App\Models\Order;
use App\Repositories\OrderRepository;
use App\Payment\PaymentGateway;

final class OrderService
{
    public function __construct(
        private readonly OrderRepository $orders,
        private readonly PaymentGateway $payments,
    ) {}

    public function all(): array
    {
        return cache()->remember('orders.all', 300, fn () => $this->orders->all());
    }

    public function create(array $data): Order
    {
        $order = $this->orders->create($data);
        $this->payments->charge($order);
        event(new OrderPlaced($order));

        return $order;
    }

    public function cancel(Order $order): void
    {
        if ($order->isShipped()) {
            throw new \RuntimeException('Cannot cancel a shipped order.');
        }

        $this->orders->delete($order);
    }
}

Output — annotated:

<?php

declare(strict_types=1);

namespace App\Services;

use App\Events\OrderPlaced;
use App\Exceptions\InsufficientStockException;
use App\Exceptions\PaymentFailedException;
use App\Models\Order;
use App\Payment\PaymentGateway;
use App\Repositories\OrderRepository;
use JustSteveKing\Signal\Attributes\Cached;
use JustSteveKing\Signal\Attributes\DependsOn;
use JustSteveKing\Signal\Attributes\Emits;
use JustSteveKing\Signal\Attributes\Service;
use JustSteveKing\Signal\Attributes\SideEffect;
use JustSteveKing\Signal\Attributes\Throws;

#[Service(
    description: 'Manages order creation, retrieval, and cancellation.',
    tags: ['orders'],
)]
#[DependsOn(class: OrderRepository::class)]
#[DependsOn(class: PaymentGateway::class, description: 'Charges the customer on order creation.')]
final class OrderService
{
    public function __construct(
        private readonly OrderRepository $orders,
        private readonly PaymentGateway $payments,
    ) {}

    #[Cached(ttl: 300, key: 'orders.all', description: 'Full order list cached for 5 minutes.')]
    public function all(): array
    {
        return cache()->remember('orders.all', 300, fn () => $this->orders->all());
    }

    #[Emits(event: 'OrderPlaced', description: 'Fired after the order is persisted and charged.')]
    #[SideEffect(description: 'Charges the customer via the payment gateway.', tags: ['payments'])]
    #[Throws(exception: PaymentFailedException::class, description: 'When the payment gateway rejects the charge.')]
    #[Throws(exception: InsufficientStockException::class, description: 'When a line item cannot be reserved.')]
    public function create(array $data): Order
    {
        $order = $this->orders->create($data);
        $this->payments->charge($order);
        event(new OrderPlaced($order));

        return $order;
    }

    #[Throws(exception: \RuntimeException::class, description: 'When the order has already shipped.')]
    public function cancel(Order $order): void
    {
        if ($order->isShipped()) {
            throw new \RuntimeException('Cannot cancel a shipped order.');
        }

        $this->orders->delete($order);
    }
}

---

$ARGUMENTS

The user may provide:

• A PHP file path to annotate
• A class description to generate
• Specific context about the domain (queue names, event names, abilities)

Use all provided context to write accurate, specific attribute values rather than generic placeholders.