Symfony Console Completion

Automatic tab-key completion for Symfony console application options, arguments and parameters
Alternatives To Symfony Console Completion
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Symfony Console Autocomplete4941126 months ago26April 11, 20223otherPHP
Shell autocompletion for Symfony Console based scripts
Symfony Console Completion4122,544626 months ago22November 24, 201912mitPHP
Automatic tab-key completion for Symfony console application options, arguments and parameters
Idea Php Annotation Plugin242
a month ago24mitJava
Add PHP annotation support for PhpStorm and IntelliJ
Zsh Symfony Completion48
6 years agoShell
(Oh My) ZSH symfony/console Completion Plugin
2 years agoapache-2.0PHP
Create command line php applications using symfony/console
Zsh Symfony Console Plugin15
9 years agoShell
Oh My Zsh plugin for the Symfony Console component
Symfony Plugin7
8 years ago1PHP
A Symfony2 plugin for padawan.php
Fish Sf6
5 years agomitShell
Symfony2 console completion for fishshell
Restaurant Search Example5
6 years ago1PHP
A companion project for our blog post on Elasticsearch's completion suggester.
Upstartbundle5115 years ago16March 03, 20181gpl-3.0PHP
Symfony bundle for painless Upstart configuration.
Alternatives To Symfony Console Completion
Select To Compare

Alternative Project Comparisons

BASH/ZSH auto-complete for Symfony Console applications

Build Status Scrutinizer Code Quality

Latest Stable Version Total Downloads Latest Unstable Version License

This package provides automatic (tab) completion in BASH and ZSH for Symfony Console Component based applications. With zero configuration, this package allows completion of available command names and the options they provide. User code can define custom completion behaviour for argument and option values.

Example of zero-config use with Composer:

Composer BASH completion

Zero-config use

If you don't need any custom completion behaviour, you can simply add the completion command to your application:

  1. Install stecman/symfony-console-completion using composer by running:

    $ composer require stecman/symfony-console-completion
  2. For standalone Symfony Console applications, add an instance of CompletionCommand to your application's Application::getDefaultCommands() method:

    protected function getDefaultCommands()
        $commands[] = new \Stecman\Component\Symfony\Console\BashCompletion\CompletionCommand();

    For Symfony Framework applications, register the CompletionCommand as a service in app/config/services.yml:

          class: Stecman\Component\Symfony\Console\BashCompletion\CompletionCommand
              -  { name: console.command }
  3. Register completion for your application by running one of the following in a terminal, replacing [program] with the command you use to run your application (eg. 'composer'):

    # BASH ~4.x, ZSH
    source <([program] _completion --generate-hook)
    # BASH ~3.x, ZSH
    [program] _completion --generate-hook | source /dev/stdin
    # BASH (any version)
    eval $([program] _completion --generate-hook)

    By default this registers completion for the absolute path to you application, which will work if the program is accessible on your PATH. You can specify a program name to complete for instead using the --program option, which is required if you're using an alias to run the program.

  4. If you want the completion to apply automatically for all new shell sessions, add the command from step 3 to your shell's profile (eg. ~/.bash_profile or ~/.zshrc)

Note: The type of shell (ZSH/BASH) is automatically detected using the SHELL environment variable at run time. In some circumstances, you may need to explicitly specify the shell type with the --shell-type option.

The current version supports Symfony 6 and PHP 8.x only, due to backwards compatibility breaks in Symfony 6. For older versions of Symfony and PHP, use version 0.11.0.

How it works

The --generate-hook option of CompletionCommand generates a small shell script that registers a function with your shell's completion system to act as a bridge between the shell and the completion command in your application. When you request completion for your program (by pressing tab with your program name as the first word on the command line), the bridge function is run; passing the current command line contents and cursor position to [program] _completion, and feeding the resulting output back to the shell.

Defining value completions

By default, no completion results will be returned for option and argument values. There are two ways of defining custom completion values for values: extend CompletionCommand, or implement CompletionAwareInterface.

Implementing CompletionAwareInterface

CompletionAwareInterface allows a command to be responsible for completing its own option and argument values. When completion is run with a command name specified (eg. myapp mycommand ...) and the named command implements this interface, the appropriate interface method is called automatically:

class MyCommand extends Command implements CompletionAwareInterface

    public function completeOptionValues($optionName, CompletionContext $context)
        if ($optionName == 'some-option') {
            return ['myvalue', 'other-value', 'word'];

    public function completeArgumentValues($argumentName, CompletionContext $context)
        if ($argumentName == 'package') {
            return $this->getPackageNamesFromDatabase($context->getCurrentWord());

This method of generating completions doesn't support use of CompletionInterface implementations at the moment, which make it easy to share completion behaviour between commands. To use this functionality, you'll need write your value completions by extending CompletionCommand.

Extending CompletionCommand

Argument and option value completions can also be defined by extending CompletionCommand and overriding the configureCompletion method:

class MyCompletionCommand extends CompletionCommand
    protected function configureCompletion(CompletionHandler $handler)
            // Instances of Completion go here.
            // See below for examples.

The Completion class

The following snippets demonstrate how the Completion class works with CompletionHandler, and some possible configurations. The examples are for an application with the signature:

`myapp (walk|run) [-w|--weather=""] direction`
Command-specific argument completion with an array
    new Completion(
        'walk',                    // match command name
        'direction',               // match argument/option name
        Completion::TYPE_ARGUMENT, // match definition type (option/argument)
        [                     // array or callback for results

This will complete the direction argument for this:

$ myapp walk [tab]

but not this:

$ myapp run [tab]
Non-command-specific (global) argument completion with a function
    new Completion(
        function() {
            return range(1, 10);

This will complete the direction argument for both commands:

$ myapp walk [tab]
$ myapp run [tab]
Option completion

Option handlers work the same way as argument handlers, except you use Completion::TYPE_OPTION for the type.

    new Completion(
            'everything is on fire!'
Completing the for both arguments and options

To have a completion run for both options and arguments matching the specified name, you can use the type Completion::ALL_TYPES. Combining this with Completion::ALL_COMMANDS and consistent option/argument naming throughout your application, it's easy to share completion behaviour between commands, options and arguments:

    new Completion(
        function() {
            // ...

Example completions

Completing references from a Git repository

new Completion(
    function () {
        $raw = shell_exec('git show-ref --abbr');
        if (preg_match_all('/refs\/(?:heads|tags)?\/?(.*)/', $raw, $matches)) {
            return $matches[1];

Completing filesystem paths

This library provides the completion implementation ShellPathCompletion which defers path completion to the shell's built-in path completion behaviour rather than implementing it in PHP, so that users get the path completion behaviour they expect from their shell.

new Completion\ShellPathCompletion(

Behaviour notes

  • Option shortcuts are not offered as completion options, however requesting completion (ie. pressing tab) on a valid option shortcut will complete.
  • Completion is not implemented for the --option="value" style of passing a value to an option, however --option value and --option "value" work and are functionally identical.
  • Value completion is always run for options marked as InputOption::VALUE_OPTIONAL since there is currently no way to determine the desired behaviour from the command line contents (ie. skip the optional value or complete for it)
Popular Symfony Projects
Popular Completion Projects
Popular Frameworks Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Command Line
Symfony Console