symfony/console

This system is the Symfony Console component, a library for building command-line interfaces and managing CLI applications. It provides a structured framework for defining commands with typed arguments, handling interactive user input, and formatting terminal output with advanced styling and shell autocompletion. The component also integrates with broader ecosystem features like dependency injection, asynchronous message handling, and continuous integration reporting.

15 changes.

This period focused on a comprehensive restructuring of the Symfony Console component to support version 8.2, introducing a tree-based command architecture, shell autocompletion, and modern PHP 8.4 features like attributes and invokable commands. Significant enhancements included expanded output capabilities with 256-color support, hyperlinks, and a new descriptor system, alongside robust event handling for command lifecycles and signals. The work concluded with extensive test coverage and dependency updates to align with the Symfony 8.0 ecosystem.

19 changes.

This period focused on significantly enhancing the Symfony Console component by introducing modern developer experience features such as SymfonyStyle for consistent output formatting, a robust Question API with validation, and lazy-loading command loaders for improved performance. The work also expanded infrastructure support through dedicated exception hierarchies, signal management, and CI reporter integrations for GitHub Actions and GitLab, ensuring comprehensive test coverage for all new functionality.

15 changes.

This period focused on modernizing the Console component by introducing PHP attributes for command definition and adding comprehensive shell autocompletion support for Bash, Fish, and Zsh. It also expanded integration capabilities by enabling commands to run asynchronously via Messenger and allowing them to be profiled within the WebProfiler.

10 changes.

This period focused on overhauling Symfony Console's argument handling by introducing an extensible ArgumentResolver system that automatically resolves typed inputs, backed enums, UIDs, and services. It also added native support for file inputs and inline image display in compatible terminals like iTerm2 and Kitty, accompanied by comprehensive test coverage for these new features.

The Console component now supports structured error reporting for continuous integration environments. A new \GithubActionReporter\ class allows linters to emit GitHub Actions workflow commands (annotations) for errors, warnings, and debug messages, enabling native integration with GitHub's UI. Additionally, a \GitlabCiReporter\ class has been added to collect issues and output a JSON report in the GitLab Code Quality format, allowing linting results to be displayed as part of GitLab CI/CD pipeline artifacts.

CI · high confidence

Introduces RunCommandMessage, RunCommandMessageHandler, and RunCommandContext classes, enabling Symfony Console commands to be dispatched and executed asynchronously via the Messenger component. The handler executes the specified command input, captures its output and exit code, and respects the message's throwOnFailure and catchExceptions flags to determine error handling behavior.

Messenger · high confidence

Introduces a new CommandDataCollector that enables profiling for console commands. This collector gathers detailed execution metrics including duration, memory usage, exit codes, and signal interruptions, while also capturing command metadata such as verbosity level, interactivity, and input/output details for display in the web profiler.

DataCollector · high confidence

The new \Interaction\ class enables interactive invokable commands by handling the execution of command methods with input resolution. It supports the \\#\[MapInput\]\ attribute to automatically map input values to method parameters, allowing commands to interactively prompt for and resolve arguments during execution.

Interaction · high confidence

Symfony Console now supports lazy-loading of commands through two new loader implementations: \ContainerCommandLoader\, which resolves commands from a PSR-11 container using a command-to-service map, and \FactoryCommandLoader\, which instantiates commands via provided factory closures. These loaders are governed by the new \CommandLoaderInterface\, allowing applications to defer command instantiation until they are actually invoked, thereby improving startup performance for standalone applications with many commands.

CommandLoader · high confidence

This change introduces new output formatters in the Completion/Output directory that transform completion suggestions into shell-specific formats. It adds BashCompletionOutput, FishCompletionOutput, and ZshCompletionOutput classes, all implementing the new CompletionOutputInterface. These formatters handle value and option suggestions, including support for negatable options (e.g., --no-option), and Fish/Zsh outputs include option descriptions. This enables users to generate proper completion scripts for these shells.

Completion/Output · high confidence

Symfony Console now provides built-in shell completion scripts for Bash, Fish, and Zsh, located in the Resources directory. These scripts enable tab-completion for commands, options, and arguments by invoking the internal \\_complete\ command with the appropriate shell-specific flags (\-sbash\, \-sfish\, \-szsh\). The implementation handles alias resolution, quote stripping, and proper escaping of special characters to ensure accurate suggestions across different shell environments.

Resources · high confidence

A new ConsoleLogger class has been introduced in the Console component, providing a standalone implementation of the PSR-3 logging interface. This logger writes log messages to the console output, mapping PSR log levels to appropriate verbosity levels and error outputs. It includes a hasErrored() method to track if any error-level messages have been logged, and supports context interpolation for dynamic message formatting.

Logger · high confidence

Introduces new \ITerm2Protocol\ and \KittyGraphicsProtocol\ classes within the \Symfony\\Component\\Console\\Terminal\\Image\ namespace, implementing the \ImageProtocolInterface\ to enable inline image display in compatible terminals. The \ITerm2Protocol\ class handles the OSC 1337 protocol, supporting both BEL and ESC\\ string terminators for decoding pasted images, while \KittyGraphicsProtocol\ implements the Kitty Graphics Protocol, including logic to reassemble chunked APC sequences into complete images and enforcing PNG format constraints during encoding.

Terminal · high confidence

The Console component has been reorganized to support version 8.2, introducing a new \CommandChain\ to manage invocations of spaced sub-commands (e.g., \cache clear\) as a tree of resolved commands with bound input at each level. A new \ConsoleBundle\ is added to provide dependency injection, autodiscovery, and autowiring for console applications. The \CHANGELOG\ documents several new features including \InputOption::HIDDEN\ and \DEPRECATED\ modes, callable descriptions in \\#\[AsCommand\]\, and a result-based testing API with \CommandTester::run()\ and \ConsoleAssertionsTrait\. Additionally, the component now supports reading multiple files via \InputFile\, validates question input using Validator constraints, and allows union/intersection type-hints for autowiring command arguments.

(repo-wide) · high confidence

The Console component's output formatter has been refactored to support nested styles via a new style stack and to render terminal hyperlinks. Users can now define custom styles using the new \OutputFormatterStyle\ class, which includes support for foreground/background colors, options, and hyperlinks (via the \setHref\ method). The formatter intelligently disables hyperlink rendering in terminals that do not support it gracefully (such as JetBrains IDEs or older Konsole versions). Additionally, a \NullOutputFormatter\ and \NullOutputFormatterStyle\ have been introduced to provide no-op implementations for scenarios where formatting is not required, and the \OutputFormatter\ class now uses a \OutputFormatterStyleStack\ to manage nested style contexts correctly.

Formatter · high confidence

The Console component now supports 256-color (Ansi8) output in addition to the standard 4-bit colors, allowing for richer terminal formatting. It also respects the NO\_COLOR environment variable to disable color output when set, and introduces a new Silent verbosity level that suppresses all output, including errors. Additionally, the OutputInterface has been updated to use a bitmask for options, combining verbosity and output type settings.

Output · high confidence

The Debug component now includes a new CliRequest class that wraps console commands as HTTP-like requests, allowing them to be profiled by the WebProfilerBundle. This change enables users to view detailed execution traces, input/output data, and performance metrics for CLI commands directly in the web profiler interface, treating command execution similarly to web requests for debugging purposes.

Debug · high confidence

Adds the \SymfonyStyle\ class and its \StyleInterface\ to the Console component, providing a set of pre-styled output methods (such as \block\, \title\, \section\, \listing\, \success\, \error\, \warning\, \note\, \caution\, and \info\) that allow command authors to produce consistent, visually structured console output following the Symfony style guide.

Style · high confidence

This change adds a new set of PHP attributes to the Console component, allowing developers to define commands, arguments, and options using code annotations instead of the traditional \configure()\ method. The \\#\[AsCommand\]\ attribute registers a class or method as a command, while \\#\[Argument\]\ and \\#\[Option\]\ define the command's inputs with support for descriptions, defaults, and suggested values. Additionally, \\#\[Ask\]\ and \\#\[AskChoice\]\ enable interactive prompts within invokable commands, and \\#\[MapInput\]\ supports mapping input to Data Transfer Objects (DTOs). These attributes are processed by new value resolvers to handle input binding and validation.

Attribute · high confidence

The Console component introduces a new, decoupled Descriptor system that standardizes how application and command metadata is serialized. This change adds support for describing negatable input options (e.g., \--foo\ and \--no-foo\) across all formats, ensuring that the JSON, XML, Markdown, ReStructuredText, and Text descriptors correctly expose these flags and their negated counterparts. The new \ApplicationDescription\ class centralizes command inspection and sorting, while the \Descriptor\ base class uses a \match\ expression to route descriptions to the appropriate handler. Users will see improved consistency in command listings, with hidden commands and options now properly handled via a \show-hidden-options\ flag, and the JSON/XML descriptors now including application name and version in their output.

Descriptor · high confidence

The Console component introduces a suite of new event classes to provide finer control over command execution and lifecycle. ConsoleCommandEvent allows listeners to skip command execution entirely, while ConsoleAlarmEvent and ConsoleSignalEvent enable handling of alarm and OS signals with configurable exit codes. ConsoleErrorEvent standardizes error handling by exposing the thrown throwable and allowing exit code overrides. ConsoleTerminateEvent is dispatched upon command completion (including signal interruptions) to allow final exit code manipulation. Additionally, QuestionAnsweredEvent supports validation constraints on user input questions by exposing violations. These events are marked as final to ensure stability.

Event · high confidence

The Helper namespace now includes several new classes to enhance console capabilities: DebugFormatterHelper provides colored, session-based debugging output for external processes; DescriptorHelper unifies object description across text, XML, JSON, Markdown, and RST formats; Dumper offers a lightweight variable dumper that falls back to print\_r when the VarDumper component is absent; FileInputHelper enables interactive file selection with paste detection and image thumbnail support; InputAwareHelper provides a base class for helpers that need access to the input interface; OutputWrapper implements regex-based text wrapping that respects ANSI tags and URLs; ProcessHelper wraps the Process component with integrated debug formatting and error handling; ProgressIndicator replaces the stateful ProgressHelper with a simpler, animated spinner interface; and SymfonyQuestionHelper enforces style-guide-compliant prompts for questions and choices.

Helper · high confidence

The Console component introduces a modernized Question API with new classes: Question now supports multiline input, configurable timeouts, and Validator constraints for robust input validation; ChoiceQuestion allows non-string choices and fixes multi-select handling with spaces; ConfirmationQuestion adds i18n support via a configurable regex for yes/no answers; and FileQuestion enables users to paste multiple files or provide file paths directly in the console.

Question · high confidence

A new service configuration file for the Console component has been added, registering a suite of argument value resolvers. This enables automatic resolution of command arguments for backed enums, UIDs, and file inputs, alongside existing support for built-in types, dates, and services. Users can now pass these specific data types directly to console commands without manual parsing.

Resources/config · high confidence

Two new event subscribers have been added to the Console component. ErrorListener now logs console errors as critical messages and terminal exit codes as debug messages, providing clearer visibility into command failures and non-zero exits. Additionally, ValidateQuestionInputListener enables automatic validation of user answers in interactive questions using the Validator component, allowing developers to attach constraints to question inputs to enforce data integrity.

EventListener · high confidence

The Console component now includes a dedicated Completion namespace with new classes (CompletionInput, CompletionSuggestions, Suggestion) that enable shell autocompletion for command arguments and options. CompletionInput parses terminal input to determine the completion context (argument value, option value, or option name), while CompletionSuggestions allows developers to register suggested values and options. This infrastructure supports advanced completion features like descriptions for suggestions and handles incomplete or invalid input gracefully during the completion process.

Completion · high confidence

The Console component now includes a dedicated SignalRegistry and SignalMap to manage process signals more robustly. SignalRegistry allows registering multiple handlers for the same signal, supports pushing and popping handler scopes to prevent leaks after command termination, and enables scheduling OS-level alarm signals via a new console.alarm event. SignalMap provides a way to resolve signal integers to their names using reflection on the pcntl extension.

SignalRegistry · high confidence

This change introduces a new \ValueResolverInterface\ and a suite of concrete resolvers in the \ArgumentResolver/ValueResolver\ directory, fundamentally changing how command arguments and options are resolved. Users can now automatically resolve typed inputs without manual parsing: \BuiltinTypeValueResolver\ handles native PHP types (string, bool, int, float, array); \BackedEnumValueResolver\ and \UidValueResolver\ resolve backed enums and UIDs (UUID/ULID) from strings; \DateTimeValueResolver\ parses dates using the \\#\[MapDateTime\]\ attribute; \InputFileValueResolver\ converts file paths to \InputFile\ objects; \ServiceValueResolver\ injects services from the container; and \MapInputValueResolver\ aggregates multiple inputs into DTOs with validation support. A \TraceableValueResolver\ is also added to profile these resolutions.

ArgumentResolver/ValueResolver · high confidence

The Console component now supports shell autocompletion for Bash, Zsh, and Fish, introduced via the new \completion\ command (DumpCompletionCommand) and the internal \\|\_complete\ command (CompleteCommand). Additionally, commands can now be defined as invokable classes or callables using the \\#\[AsCommand\]\ attribute, with automatic input binding via \\#\[MapInput\]\, \\#\[Input\]\, and \\#\[Option\]\ attributes, replacing the previous \setCode\ pattern. The \Command\ class now implements \SignalableCommandInterface\ to handle process signals, and \LazyCommand\ enables deferred command loading for improved startup performance.

Command · high confidence

Console commands can now accept file inputs via the new \InputFile\ class and \InputFileType\ helper. Users can pass files by path or paste image data directly into the terminal, with automatic MIME type detection and temporary file cleanup. The \\#\[Ask\]\ attribute and \QuestionHelper\ have been updated to recognize and handle these file inputs, allowing commands to process single files or collections of files specified in PHPDoc annotations.

Input/File · high confidence

The Symfony Console component now provides a set of specific, domain-driven exception classes (such as CommandNotFoundException, InputValidationFailedException, and InvalidOptionException) that implement the new ExceptionInterface extending \\Throwable. This replaces the previous reliance on generic SPL exceptions, allowing users to catch and handle console-specific errors with greater precision and type safety.

Exception · high confidence

The Console Input component introduces several behavioral changes to how command-line arguments and options are handled. It now supports negatable options (e.g., --ansi/--no-ansi) via the new VALUE\_NEGATABLE mode, allowing commands to toggle features on or off. The parser respects the end-of-options signal (--) to stop processing flags, and allows defining options with multiple shortcuts. Additionally, the RawInputInterface provides access to unmerged input values and an unparse() method to reconstruct CLI strings, while InputArgument and InputOption now support completion suggestions for shell autocompletion. The component also enforces stricter validation, such as rejecting non-scalar argument values in ArgvInput and preventing incompatible mode combinations.

Input · high confidence

CommandTester and ApplicationTester now return the command's exit status code instead of just the display output, allowing tests to verify success or failure via the new \assertCommandIsSuccessful()\, \assertCommandFailed()\, and \assertCommandIsInvalid()\ helpers. The testers also support capturing standard error separately from standard output through the \capture\_stderr\_separately\ option, and \CommandTester\ now accepts invokable commands in its constructor for easier testing of single-method commands.

Tester · high confidence

The Console Tester now provides more descriptive error messages when command assertions fail. New constraint classes (CommandFailed, CommandIsInvalid, CommandIsSuccessful) include additional failure descriptions that clarify whether a command was successful, failed, or invalid, making it easier to diagnose test failures.

Tester/Constraint · high confidence

Console commands now use a new \ArgumentResolver\ component to resolve method arguments from input, replacing the previous implicit resolution logic. This change introduces a chain of value resolvers (for built-in types, backed enums, dates, and files) and allows developers to inject custom resolvers or pin specific ones via attributes. Core utility types like \InputInterface\ and \OutputInterface\ are now explicitly excluded from this resolution chain to prevent conflicts, and a \TraceableArgumentResolver\ is provided to profile resolution performance.

ArgumentResolver · high confidence

The DependencyInjection component now includes four new compiler passes to manage console commands more efficiently. AddConsoleCommandPass handles the registration of commands, supporting both traditional tagged services and the new \#\[AsCommand\] attribute, while also enabling lazy command loading via a centralized ContainerCommandLoader. ConsoleArgumentValueResolverPass configures the argument resolvers used by commands, including debug wrappers when in debug mode. RegisterCommandArgumentLocatorsPass creates service locators for command arguments, allowing services to be injected into command constructors or \_\_invoke methods based on type hints and \#\[Autowire\] attributes. Finally, RemoveEmptyCommandArgumentLocatorsPass cleans up any empty service locators generated during the process to keep the container lean.

DependencyInjection · high confidence

Add shell completion integration tests for Bash, Zsh, and Fish; Added comprehensive test suite for SymfonyStyle; Added test coverage for Console Question components; Added test fixtures for Symfony Console component; Added test fixtures for SymfonyStyle command output formatting; Added test for STDIN-based interactive input handling; Added tests for ApplicationTester and CommandTester enhancements; Added tests for CI reporter classes; Added tests for CompletionInput parsing and binding; Added tests for Console Argument Resolvers; Added tests for Console DependencyInjection compiler passes; Added tests for Console Descriptors; Added tests for Console ErrorListener; Added tests for Console Tester constraints; Added tests for Console component features; Added tests for ConsoleLogger; Added tests for RunCommandFailedException code handling; Added tests for RunCommandMessageHandler; Added tests for SignalRegistry and SignalMap; Added tests for SingleCommandApplication; Added tests for SymfonyStyle progress iteration output; Added tests for iTerm2 and Kitty graphics image protocols; Added tests for shell completion output formatting; Added tests for signal handling in Console commands; Added tests for the new InputFile and InputFileType components; Added unit tests for Console Output components.

The Symfony Console component has been updated to version 8.0, raising the minimum PHP version requirement to 8.4.1. This release introduces compatibility with Symfony 8.0 components (such as DependencyInjection, EventDispatcher, and HttpKernel) while maintaining support for Symfony 7.4 components. It also adds a dependency on symfony/polyfill-php85 to ensure compatibility with PHP 8.5 features.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 45 → 55 (+9.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 88 → 84 (-3.5)
• Architecture 94 → 98 (+3.9)
• Maturity 49 → 48 (-1.2)
• Readiness 17 → 38 (+21.5)
• Security 100 → 100 (+0.0)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (11 lines × 2) (Terminal.php)
• Duplicated block (12 lines × 2) (Tests/Output/AnsiColorModeTest.php)
• Duplicated block (13 lines × 2) (Tests/ArgumentResolver/ValueResolver/BackedEnumValueResolverTest.php)
• Duplicated block (13 lines × 2) (Tests/Input/ArgvInputTest.php)
• Duplicated block (14 lines × 2) (Tests/ApplicationTest.php)
• Duplicated block (14 lines × 4) (Tests/Helper/QuestionHelperTest.php)
• Duplicated block (5 lines × 2) (Tests/Formatter/OutputFormatterTest.php)
• Duplicated block (5 lines × 2) (Tests/Helper/SymfonyQuestionHelperTest.php)
• Duplicated block (5 lines × 2) (Tests/Helper/TreeHelperTest.php)
• Duplicated block (5 lines × 3) (Tests/Completion/CompletionInputTest.php)
• Duplicated block (6 lines × 2) (Tests/Command/InvokableCommandTest.php)
• Duplicated block (6 lines × 2) (Tests/Command/InvokableCommandTest.php)
• Duplicated block (6 lines × 2) (Tests/Command/InvokableCommandTest.php)
• Duplicated block (6 lines × 2) (Tests/Input/InputOptionTest.php)
• Duplicated block (6 lines × 3) (Tests/ArgumentResolver/ValueResolver/MapInputValueResolverTest.php)
• Duplicated block (6 lines × 3) (Tests/Tester/CommandTesterTest.php)
• Duplicated block (7 lines × 2) (Helper/DebugFormatterHelper.php)
• Duplicated block (7 lines × 2) (Tests/ArgumentResolver/ValueResolver/ServiceValueResolverTest.php)
• …and 12 more

• AddConsoleCommandPass.process (cognitive 28) (DependencyInjection/AddConsoleCommandPass.php)
• AddConsoleCommandPass.process (cyclomatic 16) (DependencyInjection/AddConsoleCommandPass.php)
• AddConsoleCommandPass.registerCommand (cognitive 42) (DependencyInjection/AddConsoleCommandPass.php)
• AddConsoleCommandPass.registerCommand (cyclomatic 30) (DependencyInjection/AddConsoleCommandPass.php)
• Application.all (cognitive 20) (Application.php)
• Application.configureIO (cyclomatic 24) (Application.php)
• Application.doRenderThrowable (cognitive 57) (Application.php)
• Application.doRenderThrowable (cyclomatic 25) (Application.php)
• Application.doRun (cognitive 66) (Application.php)
• Application.doRun (cyclomatic 35) (Application.php)
• Application.doRunCommand (cognitive 56) (Application.php)
• Application.doRunCommand (cyclomatic 25) (Application.php)
• Application.find (cognitive 45) (Application.php)
• Application.find (cyclomatic 28) (Application.php)
• Application.findAlternatives (cognitive 24) (Application.php)
• Application.findAlternatives (cyclomatic 16) (Application.php)
• Application.resolveCommandTree (cognitive 47) (Application.php)
• Application.resolveCommandTree (cyclomatic 29) (Application.php)
• Application.run (cognitive 33) (Application.php)
• Application.run (cyclomatic 24) (Application.php)
• …and 190 more

• 108 commits — 90 feature/other, 18 fixes

• (repo) — 57 commits
• (root) — 10 commits
• Tests/shell-completion — 5 commits
• ArgumentResolver/ValueResolver — 3 commits
• Command/Command.php — 3 commits
• Helper/QuestionHelper.php — 3 commits
• Tests/Fixtures — 3 commits
• Formatter/OutputFormatter.php — 2 commits
• Helper/OutputWrapper.php — 2 commits
• Resources/completion.zsh — 2 commits
• Tests/Command — 2 commits
• ArgumentResolver/ArgumentResolver.php — 1 commit
• Attribute/Argument.php — 1 commit
• Attribute/AsCommand.php — 1 commit
• Attribute/Ask.php — 1 commit
• Command/InvokableCommand.php — 1 commit
• Debug/CliRequest.php — 1 commit
• DependencyInjection/RegisterCommandArgumentLocatorsPass.php — 1 commit
• Helper/FileInputHelper.php — 1 commit
• Helper/ProcessHelper.php — 1 commit

• fix: PHP CS Fixer: fix minor detected issues
• fix: Revert "feature #64723 [Console] Add a listedAt option to list a command only from a given verbosity (jprivet-dev)"
• fix: [Console] Fix "regular expression is too large" when wrapping on wide terminals
• fix: [Console] Fix ULID resolving on low deps
• fix: [Console] Fix clearing more lines than a section holds
• fix: [Console] Fix decoding chunked Kitty graphics payloads
• fix: [Console] Fix parsing #[Target] attribute on arguments of invokable commands
• fix: [Console] Fix service arguments not resolved when a command is invoked by alias or abbreviation
• fix: [Console] Fix signal handling of invokable commands registered through the container
• fix: [Console] Fix terminator handling in the image protocols
• fix: [Console] Fix the bash completion of "--option=value" and of an aliased command
• fix: [Console] Fix the bash completion on macOS and cover more option modes
• fix: [Console] Fix writing one-shot iterables to a CombinedOutput
• fix: [Console] Test the shell completion scripts and fix the escaping
• fix: [Console][FrameworkBundle] Fix profiling a command stopped at ConsoleEvents::COMMAND
• fix: bug #65500 [Console] Keep backslashes preceding < and > when escaping text (nicolas-grekas)
• fix: bug #65851 [Console] Make method-level #[AsCommand] names relative to the class-level one (nicolas-grekas)
• fix: feature #65304 [Console] Revert "Add a listedAt option to list a command only from a given verbosity" (MatTheCat)
• change: Adapt merged-up tests to 8.1
• change: Check arrays and bools directly instead of comparing them to count()/true/false/[]
• …and 88 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

symfony/console was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.