Verifies that the changelog contains meaningful unreleased changes.

Applies changelog mutations and derives release metadata.

Parses managed changelog markdown into domain objects.

Renders managed changelog domain objects into markdown.

Defines DevTools-specific Composer plugin conventions.

Defines the contract for reading and exposing normalized metadata from a Composer `composer.json` file.

Defines the contract for representing an author entry within a composer.json file.

Defines the contract for representing a single entry of the "funding" section of a composer.json file.

Defines the contract for representing the "support" section of a composer.json file.

Defines a processor that transforms log context payloads.

Detects console output capabilities without requiring PTY-backed processes.

Reads process environment variables without binding callers to Composer APIs.

Answers common runtime-environment questions from process environment flags.

Defines a standard file system interface with enhanced path resolution.

Creates fresh Symfony Finder instances for each filesystem scan.

Provides semantic Git operations for repository-aware services.

Provides the canonical list of candidate paths for export-ignore rules.

Checks the existence of files and directories in a given base path.

Filters canonical export-ignore candidates against consumer keep rules.

Merges export-ignore entries with existing .gitattributes content.

Defines the contract for reading .gitattributes files from persistent storage.

Defines the contract for writing .gitattributes files to persistent storage.

Defines the contract for classifying .gitignore entries.

Defines the contract for a .gitignore file with its path and entries.

Defines the contract for merging .gitignore entries.

Defines the contract for reading .gitignore files from a storage location.

Defines the contract for writing .gitignore representations to persistent storage.

Generates LICENSE files from composer.json metadata.

Resolves license identifiers to their corresponding template filenames.

Checks PHP runtime extension availability without coupling callers to global functions.

Loads PHPUnit `coverage-php` reports and exposes their line coverage summary.

Defines a fluent builder responsible for constructing process instances.

Configures subprocess environment variables before queued execution.

Defines a queue responsible for collecting and executing process instances.

Resolves the effective documentation, testing, and wiki capabilities of the current repository.

Defines the contract for generating unified diffs.

Runs the Composer command that updates the installed DevTools package.

Resolves whether self-update SHOULD target the local project or Composer global project.

Checks whether the installed DevTools package is behind the latest stable release.

Emits non-blocking DevTools freshness notices for interactive binary runs.

Switches the process working directory before command execution starts.

Compares unreleased changelog entries against the current branch or a base ref.

Rebuilds the active Unreleased section from predictable changelog conflicts.

Normalizes minimal changelog entry messages for Dependabot pull requests.

Represents the minimal Keep a Changelog document structure used by dev-tools.

Represents one Keep a Changelog release section.

Applies changelog mutations and derived release metadata.

Parses the subset of Keep a Changelog structure managed by dev-tools.

Renders Keep a Changelog markdown in a deterministic package-friendly format.

Generates CODEOWNERS content from repository metadata.

Provides a registry of custom dev-tools commands mapped for Composer integration.

Adapts migrated Symfony commands to Composer's BaseCommand contract.

Represents a specialized reader for a Composer JSON file.

Concrete implementation of the ComposerJsonAuthorInterface.

Represents a single funding entry from the optional "funding" section of a composer.json file.

Represents the optional "support" section of a composer.json file.

Implements the lifecycle of the Composer dev-tools extension framework.

Provides the default Composer Dependency Analyser configuration.

Provides the default ECS configuration.

Provides the default Rector configuration.

Synchronizes packaged Fast Forward project agents into the consumer repository.

Verifies that the changelog contains pending unreleased notes.

Inserts a changelog entry into the managed changelog file.

Infers the next semantic version from changelog content.

Promotes the Unreleased section into a published changelog version.

Prints the rendered notes body for a released changelog version.

Generates and synchronizes CODEOWNERS files from local project metadata.

Represents the command responsible for checking and fixing code style issues.

Copies packaged or local resources into the consumer repository.

Orchestrates dependency analysis across the supported Composer analyzers.

Generates the package API documentation through phpDocumentor.

Synchronizes funding metadata between composer.json and .github/FUNDING.yml.

Provides functionality to manage .gitattributes export-ignore rules.

Installs packaged Git hooks for the consumer repository.

Provides functionality to merge and synchronize .gitignore files.

Generates and copies LICENSE files to projects.

Provides operations to inspect, lint, and repair PHPDoc comments across the project.

Provides functionality to execute automated code refactoring using Rector.

Coordinates documentation, coverage, and metrics report generation.

Updates the installed DevTools package through Composer.

Synchronizes packaged Fast Forward skills into the consumer repository.

Executes the full suite of Fast Forward code standard checks.

Orchestrates dev-tools synchronization commands for the consumer repository.

Facilitates the execution of the PHPUnit testing framework.

Updates composer.json with the Fast Forward dev-tools integration metadata.

Handles the generation of API documentation for the project.

Responsible for dynamically discovering and loading Symfony Console commands within the DevTools context. This class extends the ContainerCommandLoader and integrates with a PSR-11 compatible container to lazily instantiate commands.

Wraps the fast-forward console tooling suite conceptually as an isolated application instance.

Defines additional console styles for log level tags.

Formats PSR-3 log messages for the DevTools console runtime.

Expands command input instances into structured context entries.

Converts buffered command output objects into serializable context entries.

Applies multiple context processors in sequence.

Emits GitHub Actions workflow commands through the console output stream.

Detects ANSI-friendly output by decoration state or TTY-backed streams.

Builds and caches the shared DevTools dependency injection container.

Registers the services exposed by the DevTools container.

Reads environment variables through PHP's native runtime.

Resolves common runtime-environment flags used by DevTools integrations.

Concrete implementation of the standard filesystem interface.

Default factory for Symfony Finder instances.

Parses and renders Composer funding metadata.

Carries normalized funding metadata across Composer and GitHub formats.

Merges normalized funding profiles into a deterministic synchronized view.

Parses and renders GitHub funding YAML metadata.

Executes semantic Git operations using the local Git binary.

Provides the canonical list of candidate paths for export-ignore rules.

Checks the existence of files and directories in a given base path.

Filters export-ignore candidates using normalized path comparisons.

Merges .gitattributes content with generated export-ignore rules.

Reads raw .gitattributes content from the filesystem.

Persists normalized .gitattributes content.

Renders packaged Git hooks with runtime-specific DevTools hook configuration paths.

Classifies .gitignore entries as directory-oriented or file-oriented patterns.

Represents a .gitignore file with its path and entries.

Merges, deduplicates, and sorts .gitignore entries.

Reads .gitignore files and returns domain representations for them.

Renders and persists normalized .gitignore content.

Synchronizes deprecated DevTools-managed GrumPHP composer metadata without leaking package paths into consumers.

Generates LICENSE files from composer.json metadata.

Resolves license identifiers to their corresponding template filenames.

Resolves canonical paths for the DevTools package itself.

Provides canonical repository-local paths for generated DevTools artifacts.

Provides canonical repository-root paths that are not part of the managed workspace.

Checks PHP runtime extension availability through PHP's native runtime.

Generates deterministic PHPUnit bootstrap shims for working-directory test runs.

Represents the line coverage summary extracted from a PHPUnit `coverage-php` report.

Loads line coverage metrics from the serialized PHPUnit `coverage-php` output.

Collects PHPUnit events grouped by their concrete event class.

Enables BypassFinals when the PHPUnit test suite starts.

Sends a desktop notification when the PHPUnit execution finishes.

Registers the Joli notification tracer within the PHPUnit extension lifecycle.

Keeps nested process output color-friendly without requiring PTY support.

Applies multiple process environment configurators in a stable order.

Builds immutable process definitions from a command and a collection of arguments.

Executes queued processes sequentially while supporting detached entries and optional failure suppression.

Disables Xdebug for child processes unless coverage still needs it.

Captures which documentation, testing, and wiki surfaces are available for the current repository.

Resolves which repository surfaces are available to documentation, testing, and wiki tooling.

A clock implementation that returns the current system time.

Provides automated refactoring to prepend basic PHPDoc comments on classes missing them.

Executes AST inspections parsing missing documentation on methods automatically.

Implements automation targeting the removal of purposeless empty DocBlock structures natively.

Centralizes small reflection lookups used by DevTools runtime metadata.

Carries the result of comparing source and target file contents.

Renders deterministic summaries and unified diffs for file comparisons.

Generates unified diffs using the default Sebastian diff output builder.

Updates DevTools through the active Composer executable.

Detects Composer global DevTools installations from known Composer home paths.

Resolves DevTools freshness through Composer metadata without coupling callers to Composer commands.

Emits update warnings while ensuring version checks never block the requested command.

Describes the installed and latest known DevTools versions.

Applies Composer-like working-directory switching for the standalone binary.

Synchronizes one packaged directory of symlinked entries into a consumer repository.

Result object for packaged directory synchronization operations.

Resolves the logger expected by command result helper traits.

Provides reusable helpers for logging command outcomes and returning exit codes.

Provides the standard cache option used by cache-writing commands.

Provides the standard JSON output options used by DevTools commands.

Represents the supported Keep a Changelog entry categories.