The #[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:

#[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):

#[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):

#[AsCommand('app:create-user')]
class CreateUserCommand
{
    public function __invoke(
        #[Argument, Ask('Enter the username')] 
        string $username,
    ): int {
        // ...
    }
}

DTO‑friendly interaction

In 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 interactivity

You 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:

class 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:

bin/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 interactivity

For 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:

class 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 prompts

For 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:

#[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 parameters
2. #[Ask] on DTO properties
3. #[Interact] on the DTO class
4. #[Interact] on the command class

More related features will be unveiled later.

Cheers!