…ds with `#[Interact]` and `#[Ask]` attributes (yceruto)This PR was squashed before being merged into the 7.4 branch.Discussion----------[Console] Add support for interactive invokable commands with `#[Interact]` and `#[Ask]` attributes| Q             | A| ------------- | ---| Branch?       | 7.4| Bug fix?      | no| New feature?  | yes| Deprecations? | no| Issues        | -| License       | MITThe `#[Interact]` attribute lets you hook into the command *interactive phase* without extending `Command`, and unlocks even more flexibility!**Characteristics**- The method marked with `#[Interact]` attribute will be called during interactive mode- The method must be **public, non‑static**, otherwise a `LogicException` is thrown- As usual, it runs only when the interactive mode is enabled (e.g. not with `--no-interaction`)- Supports common helpers and DTOs parameters just like `__invoke()`**Before:**```php#[AsCommand('app:create-user')]class CreateUserCommand extends Command{    protected function interact(InputInterface $input, OutputInterface $output): void    {        $io = new SymfonyStyle($input, $output);        if (!$input->getArgument('username')) {            $input->setArgument('username', $io->ask('Enter the username'));        }    }    public function __invoke(#[Argument] string $username): int    {        // ...    }}```**After (long version):**```php#[AsCommand('app:create-user')]class CreateUserCommand{    #[Interact]    public function prompt(InputInterface $input, SymfonyStyle $io): void    {        if (!$input->getArgument('username')) {            $input->setArgument('username', $io->ask('Enter the username'));        }    }    public function __invoke(#[Argument] string $username): int    {        // ...    }}```This PR also adds the `#[Ask]` attribute for the most basic use cases. It lets you declare interactive prompts directly on parameters. Symfony will automatically ask the user for missing values during the interactive phase, without needing to implement a custom "interact" method yourself:**After (short version):**```php#[AsCommand('app:create-user')]class CreateUserCommand{    public function __invoke(        #[Argument, Ask('Enter the username')]        string $username,    ): int {        // ...    }}```### DTO‑friendly interactionIn more complex commands, the DTO approach (see PR#61478) lets you work directly with the DTO instance and its properties. You've got three ways to do this, so let's start with the simplest and move toward the most flexible:#### 1) Attribute-driven interactivityYou can also use the `#[Ask]` attribute on DTO properties that have the `#[Argument]` attribute and no default value; if such a property is unset when running the command (e.g. when the linked argument isn't passed), the component automatically triggers a prompt using your defined question:```phpclass UserDto{    #[Argument]    #[Ask('Enter the username')]    public string $username;    #[Argument]    #[Ask('Enter the password', hidden: true)]    public string $password;}#[AsCommand('app:create-user')]class CreateUserCommand{    public function __invoke(#[MapInput] UserDto $user): int    {        // use $user->username and $user->password    }}```Example run:```bashbin/console app:create-user Enter the username: > yceruto Enter the password: > 🔑```This makes the most common interactive cases completely declarative.> [RFC] You may also find other declarative prompts useful, such as #[Choice] (with better support for BackedEnum properties) and #[Confirm] (for bool properties).#### 2) DTO-driven interactivityFor scenarios that go beyond simple prompts, you can handle interactivity inside the DTO itself. As long as it only concerns the DTO's own properties (and doesn't require external services), you can mark a method with `#[Interact]`. Symfony will call it during the interactive phase, giving you access to helpers to implement custom logic:```phpclass UserDto{    #[Argument]    #[Ask('Enter the username')]    public string $username;    #[Argument]    #[Ask('Enter the password (or press Enter for a random one)', hidden: true)]    public string $password;    #[Interact]    public function prompt(SymfonyStyle $io): void    {        if (!isset($this->password)) {            $this->password = generate_password(10);            copy_to_clipboard($this->password);            $io->writeln('Password generated and copied to your clipboard.');        }    }}```Yes! `#[Ask]` and `#[Interact]` complement each other and are executed in sequence during the interactive phase.#### 3) Service‑aware promptsFor cases where prompts depend on external services or need a broader context, you can declare the `#[Interact]` method on the command class itself, giving you full control over the interactive phase:```php#[AsCommand('app:create-user')]class CreateUserCommand{    public function __construct(        private PasswordStrengthValidatorInterface $validator,    ) {    }    #[Interact]    public function prompt(SymfonyStyle $io, #[MapInput] UserDto $user): void    {        $user->password ??= $io->askHidden('Enter password', $this->validator->isValid(...));    }    public function __invoke(#[MapInput] UserDto $user): int    {        // ...    }}```In earlier approaches, you had to set arguments manually with `$input->setArgument()`. With DTOs, you can now work directly on typed properties, which makes the code more expressive and less error-prone.All three ways can coexist, and the execution order is:1. `#[Ask]` on `__invoke` parameters2. `#[Ask]` on DTO properties3. `#[Interact]` on the DTO class4. `#[Interact]` on the command classMore related features will be unveiled later.Cheers!Commits-------6e837c4 [Console] Add support for interactive invokable commands with `#[Interact]` and `#[Ask]` attributes

…ds with `#[Interact]` and `#[Ask]` attributes (yceruto)This PR was squashed before being merged into the 7.4 branch.Discussion----------[Console] Add support for interactive invokable commands with `#[Interact]` and `#[Ask]` attributes| Q             | A| ------------- | ---| Branch?       | 7.4| Bug fix?      | no| New feature?  | yes| Deprecations? | no| Issues        | -| License       | MITThe `#[Interact]` attribute lets you hook into the command *interactive phase* without extending `Command`, and unlocks even more flexibility!**Characteristics**- The method marked with `#[Interact]` attribute will be called during interactive mode- The method must be **public, non‑static**, otherwise a `LogicException` is thrown- As usual, it runs only when the interactive mode is enabled (e.g. not with `--no-interaction`)- Supports common helpers and DTOs parameters just like `__invoke()`**Before:**```php#[AsCommand('app:create-user')]class CreateUserCommand extends Command{    protected function interact(InputInterface $input, OutputInterface $output): void    {        $io = new SymfonyStyle($input, $output);        if (!$input->getArgument('username')) {            $input->setArgument('username', $io->ask('Enter the username'));        }    }    public function __invoke(#[Argument] string $username): int    {        // ...    }}```**After (long version):**```php#[AsCommand('app:create-user')]class CreateUserCommand{    #[Interact]    public function prompt(InputInterface $input, SymfonyStyle $io): void    {        if (!$input->getArgument('username')) {            $input->setArgument('username', $io->ask('Enter the username'));        }    }    public function __invoke(#[Argument] string $username): int    {        // ...    }}```This PR also adds the `#[Ask]` attribute for the most basic use cases. It lets you declare interactive prompts directly on parameters. Symfony will automatically ask the user for missing values during the interactive phase, without needing to implement a custom "interact" method yourself:**After (short version):**```php#[AsCommand('app:create-user')]class CreateUserCommand{    public function __invoke(        #[Argument, Ask('Enter the username')]        string $username,    ): int {        // ...    }}```### DTO‑friendly interactionIn more complex commands, the DTO approach (see PRsymfony/symfony#61478) lets you work directly with the DTO instance and its properties. You've got three ways to do this, so let's start with the simplest and move toward the most flexible:#### 1) Attribute-driven interactivityYou can also use the `#[Ask]` attribute on DTO properties that have the `#[Argument]` attribute and no default value; if such a property is unset when running the command (e.g. when the linked argument isn't passed), the component automatically triggers a prompt using your defined question:```phpclass UserDto{    #[Argument]    #[Ask('Enter the username')]    public string $username;    #[Argument]    #[Ask('Enter the password', hidden: true)]    public string $password;}#[AsCommand('app:create-user')]class CreateUserCommand{    public function __invoke(#[MapInput] UserDto $user): int    {        // use $user->username and $user->password    }}```Example run:```bashbin/console app:create-user Enter the username: > yceruto Enter the password: > 🔑```This makes the most common interactive cases completely declarative.> [RFC] You may also find other declarative prompts useful, such as #[Choice] (with better support for BackedEnum properties) and #[Confirm] (for bool properties).#### 2) DTO-driven interactivityFor scenarios that go beyond simple prompts, you can handle interactivity inside the DTO itself. As long as it only concerns the DTO's own properties (and doesn't require external services), you can mark a method with `#[Interact]`. Symfony will call it during the interactive phase, giving you access to helpers to implement custom logic:```phpclass UserDto{    #[Argument]    #[Ask('Enter the username')]    public string $username;    #[Argument]    #[Ask('Enter the password (or press Enter for a random one)', hidden: true)]    public string $password;    #[Interact]    public function prompt(SymfonyStyle $io): void    {        if (!isset($this->password)) {            $this->password = generate_password(10);            copy_to_clipboard($this->password);            $io->writeln('Password generated and copied to your clipboard.');        }    }}```Yes! `#[Ask]` and `#[Interact]` complement each other and are executed in sequence during the interactive phase.#### 3) Service‑aware promptsFor cases where prompts depend on external services or need a broader context, you can declare the `#[Interact]` method on the command class itself, giving you full control over the interactive phase:```php#[AsCommand('app:create-user')]class CreateUserCommand{    public function __construct(        private PasswordStrengthValidatorInterface $validator,    ) {    }    #[Interact]    public function prompt(SymfonyStyle $io, #[MapInput] UserDto $user): void    {        $user->password ??= $io->askHidden('Enter password', $this->validator->isValid(...));    }    public function __invoke(#[MapInput] UserDto $user): int    {        // ...    }}```In earlier approaches, you had to set arguments manually with `$input->setArgument()`. With DTOs, you can now work directly on typed properties, which makes the code more expressive and less error-prone.All three ways can coexist, and the execution order is:1. `#[Ask]` on `__invoke` parameters2. `#[Ask]` on DTO properties3. `#[Interact]` on the DTO class4. `#[Interact]` on the command classMore related features will be unveiled later.Cheers!Commits-------6e837c4b1f7 [Console] Add support for interactive invokable commands with `#[Interact]` and `#[Ask]` attributes