kulakpos_web/vendor/psy/psysh/src/Shell.php

<?php

/*
 * This file is part of Psy Shell.
 *
 * (c) 2012-2026 Justin Hileman
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Psy;

use Psy\CodeCleaner\NoReturnValue;
use Psy\Completion\CompletionEngine;
use Psy\Completion\Refiner\CommandContextRefiner;
use Psy\Completion\Source\CommandArgumentSource;
use Psy\Completion\Source\CommandOptionSource;
use Psy\Completion\Source\CommandSource;
use Psy\Completion\Source\HistorySource;
use Psy\Completion\Source\MatcherAdapterSource;
use Psy\Exception\BreakException;
use Psy\Exception\ErrorException;
use Psy\Exception\Exception as PsyException;
use Psy\Exception\InterruptException;
use Psy\Exception\RuntimeException;
use Psy\Exception\ThrowUpException;
use Psy\ExecutionLoop\ProcessForker;
use Psy\ExecutionLoop\RunkitReloader;
use Psy\ExecutionLoop\SignalHandler;
use Psy\ExecutionLoop\UopzReloader;
use Psy\Formatter\TraceFormatter;
use Psy\Input\ShellInput;
use Psy\Input\SilentInput;
use Psy\Output\ShellOutput;
use Psy\Readline\InteractiveReadlineInterface;
use Psy\Readline\LegacyReadline;
use Psy\Readline\Readline;
use Psy\Readline\ReadlineAware;
use Psy\Readline\ShellReadlineInterface;
use Psy\Shell\PendingInputState;
use Psy\TabCompletion\AutoCompleter;
use Psy\TabCompletion\Matcher;
use Psy\Util\Tty;
use Psy\VarDumper\Presenter;
use Psy\VarDumper\PresenterAware;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command as BaseCommand;
use Symfony\Component\Console\Exception\ExceptionInterface as SymfonyConsoleException;
use Symfony\Component\Console\Formatter\OutputFormatter;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\StringInput;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Output\StreamOutput;

/**
 * The Psy Shell application.
 *
 * Usage:
 *
 *     $shell = new Shell;
 *     $shell->run();
 *
 * @author Justin Hileman <justin@justinhileman.info>
 */
class Shell extends Application
{
    const VERSION = 'v0.12.22';

    private Configuration $config;
    private ?CodeCleaner $cleaner = null;
    private OutputInterface $output;
    private ?int $originalVerbosity = null;
    private ?ShellReadlineInterface $readline = null;
    private array $inputBuffer;
    private PendingInputState $pendingInput;
    private string $stdoutBuffer;
    private Context $context;
    private array $includes;
    private bool $outputWantsNewline = false;
    private array $loopListeners;
    private bool $booted = false;
    private bool $autoloadWarmed = false;
    private ?AutoCompleter $autoCompleter = null;
    private ?CompletionEngine $completionEngine = null;
    /** @var Completion\Source\SourceInterface[] */
    private array $pendingCompletionSources = [];
    private array $matchers = [];
    /** @var CommandAware[] */
    private array $commandCompletion = [];
    private bool $lastExecSuccess = true;
    private bool $suppressReturnValue = false;
    private bool $nonInteractive = false;
    private ?int $errorReporting = null;
    private bool $interactiveSignalCharsEnabled = false;
    private bool $outputWritten = false;
    private bool $legacyNeedsPromptSpacer = false;
    private bool $writingLegacySpacer = false;

    /**
     * Create a new Psy Shell.
     *
     * @param Configuration|null $config (default: null)
     */
    public function __construct(?Configuration $config = null)
    {
        $this->config = $config ?: new Configuration();
        $this->context = new Context();
        $this->includes = [];
        $this->inputBuffer = [];
        $this->pendingInput = new PendingInputState();
        $this->stdoutBuffer = '';
        $this->loopListeners = $this->getDefaultLoopListeners();

        parent::__construct('Psy Shell', self::VERSION);

        $this->config->setShell($this);

        // Register the current shell session's config with \Psy\info
        \Psy\info($this->config);
    }

    /**
     * Warm the autoloader by loading classes at startup.
     *
     * This improves tab completion by making classes available via get_declared_classes()
     * rather than maintaining a separate list of available classes.
     */
    private function warmAutoloader(): void
    {
        if ($this->autoloadWarmed) {
            return;
        }
        $this->autoloadWarmed = true;

        $warmers = $this->config->getAutoloadWarmers();
        if (empty($warmers)) {
            return;
        }

        $output = $this->config->getOutput();
        if ($output instanceof ConsoleOutput) {
            $output = $output->getErrorOutput();
        }

        $start = \microtime(true);
        $loadedCount = 0;

        foreach ($warmers as $warmer) {
            try {
                $loadedCount += $warmer->warm();
            } catch (\Throwable $e) {
                $output->writeln($this->formatException($e), OutputInterface::VERBOSITY_DEBUG);
            }
        }

        $message = \sprintf(
            '<whisper>Autoload warming: loaded %d classes in %.1fms</whisper>',
            $loadedCount,
            (\microtime(true) - $start) * 1000
        );

        $output->writeln($message, OutputInterface::VERBOSITY_DEBUG);

        if (!\class_exists('Composer\\ClassMapGenerator\\ClassMapGenerator', false)) {
            $output->writeln('<whisper>Autoload warming works best with composer/class-map-generator installed</whisper>');
        }
    }

    /**
     * Boot the shell, initializing the CodeCleaner and Readline.
     *
     * This is called lazily when commands or methods require these dependencies.
     * If input/output are provided, they'll be used for trust prompts. Otherwise,
     * falls back to config defaults.
     */
    public function boot(?InputInterface $input = null, ?OutputInterface $output = null): void
    {
        if ($this->booted) {
            return;
        }

        $this->loadLocalConfig($input, $output);

        $this->cleaner = $this->config->getCodeCleaner();
        $this->readline = $this->configureReadline($this->config->getReadline());
        $this->booted = true;

        if ($this->readline instanceof LegacyReadline) {
            $this->add(new Command\BufferCommand());
        }

        $this->refreshCommandDependencies();
    }

    /**
     * Load local config with trust prompt if needed.
     */
    private function loadLocalConfig(?InputInterface $input, ?OutputInterface $output): void
    {
        if ($output === null) {
            $output = $this->config->getOutput();
        }

        if ($input === null) {
            $input = new ArrayInput([]);
            // Programmatic callers (e.g. Shell::execute) don't provide a real
            // interactive input stream, so trust prompts must not block.
            $input->setInteractive(false);
        }

        $this->config->loadLocalConfigWithPrompt($input, $output);
    }

    /**
     * Configure a readline instance before assigning it to the shell.
     *
     * This sets up shell awareness, interactive readline dependencies,
     * output/theme integration, and options.
     *
     * @return ShellReadlineInterface The configured readline instance
     */
    private function configureReadline(Readline $readline): ShellReadlineInterface
    {
        if (!($readline instanceof ShellReadlineInterface)) {
            $readline = new LegacyReadline($readline);
        }

        if ($readline instanceof InteractiveReadlineInterface) {
            // setOutput boots the interactive readline, so it must come first
            $readline->setOutput($this->output ?? $this->config->getOutput());
            $readline->setTheme($this->config->theme());
            $readline->setRequireSemicolons($this->config->requireSemicolons());
            $readline->setUseBracketedPaste($this->config->useBracketedPaste());
            $readline->setUseSyntaxHighlighting($this->config->useSyntaxHighlighting());
            $readline->setUseSuggestions($this->config->useSuggestions());
        } else {
            $readline->setRequireSemicolons($this->config->requireSemicolons());
        }

        if ($readline instanceof LegacyReadline) {
            $readline->setBufferPrompt($this->config->theme()->bufferPrompt());
            $readline->setOutput($this->output ?? $this->config->getOutput());
        }

        $readline->setShell($this);

        return $readline;
    }

    /**
     * Refresh dependencies on all registered commands.
     */
    private function refreshCommandDependencies(): void
    {
        foreach ($this->all() as $command) {
            $this->configureCommand($command);
        }
    }

    /**
     * Configure a command with context and dependencies.
     */
    private function configureCommand(BaseCommand $command): void
    {
        if ($command instanceof ContextAware) {
            $command->setContext($this->context);
        }

        if ($this->booted) {
            if ($command instanceof CodeCleanerAware && $this->cleaner !== null) {
                $command->setCodeCleaner($this->cleaner);
            }

            if ($command instanceof PresenterAware) {
                $command->setPresenter($this->config->getPresenter());
            }

            if ($command instanceof ReadlineAware && $this->readline !== null) {
                $command->setReadline($this->readline);
            }
        }
    }

    /**
     * Check whether the first thing in a backtrace is an include call.
     *
     * This is used by the psysh bin to decide whether to start a shell on boot,
     * or to simply autoload the library.
     */
    public static function isIncluded(array $trace): bool
    {
        $isIncluded = isset($trace[0]['function']) &&
          \in_array($trace[0]['function'], ['require', 'include', 'require_once', 'include_once']);

        // Detect Composer PHP bin proxies.
        if ($isIncluded && \array_key_exists('_composer_autoload_path', $GLOBALS) && \preg_match('{[\\\\/]psysh$}', $trace[0]['file'])) {
            // If we're in a bin proxy, we'll *always* see one include, but we
            // care if we see a second immediately after that.
            return isset($trace[1]['function']) &&
                \in_array($trace[1]['function'], ['require', 'include', 'require_once', 'include_once']);
        }

        return $isIncluded;
    }

    /**
     * Check if the currently running PsySH bin is a phar archive.
     */
    public static function isPhar(): bool
    {
        return \class_exists("\Phar") && \Phar::running() !== '' && \strpos(__FILE__, \Phar::running(true)) === 0;
    }

    /**
     * Invoke a Psy Shell from the current context.
     *
     * @see Psy\debug
     * @deprecated will be removed in 1.0. Use \Psy\debug instead
     *
     * @param array         $vars   Scope variables from the calling context (default: [])
     * @param object|string $bindTo Bound object ($this) or class (self) value for the shell
     *
     * @return array Scope variables from the debugger session
     */
    public static function debug(array $vars = [], $bindTo = null): array
    {
        @\trigger_error('`Psy\\Shell::debug` is deprecated; call `Psy\\debug` instead.', \E_USER_DEPRECATED);

        return \Psy\debug($vars, $bindTo);
    }

    /**
     * Adds a command object.
     *
     * @deprecated since Symfony Console 7.4, use addCommand() instead
     *
     * @param BaseCommand $command A Symfony Console Command object
     *
     * @return BaseCommand The registered command
     */
    public function add(BaseCommand $command): BaseCommand
    {
        return $this->addCommand($command);
    }

    /**
     * Adds a command object.
     *
     * @param BaseCommand|callable $command A Symfony Console Command object or callable
     *
     * @return BaseCommand|null The registered command, or null
     */
    public function addCommand($command): ?BaseCommand
    {
        // For Symfony Console < 7.4, use parent::add()
        if (\method_exists(Application::class, 'addCommand')) {
            /** @phan-suppress-next-line PhanUndeclaredStaticMethod (Symfony Console 7.4+) */
            $ret = parent::addCommand($command);
        } else {
            $ret = parent::add($command);
        }

        if ($ret) {
            $this->configureCommand($ret);

            $allCommands = $this->all();
            foreach ($this->commandCompletion as $instance) {
                $instance->setCommands($allCommands);
            }
        }

        return $ret;
    }

    /**
     * Gets the default input definition.
     *
     * @return InputDefinition An InputDefinition instance
     */
    protected function getDefaultInputDefinition(): InputDefinition
    {
        return new InputDefinition([
            new InputArgument('command', InputArgument::REQUIRED, 'The command to execute'),
            new InputOption('--help', '-h', InputOption::VALUE_NONE, 'Display this help message.'),
        ]);
    }

    /**
     * Gets the default commands that should always be available.
     *
     * @return array An array of default Command instances
     */
    protected function getDefaultCommands(): array
    {
        $sudo = new Command\SudoCommand();

        $hist = new Command\HistoryCommand();

        $doc = new Command\DocCommand();
        $doc->setConfiguration($this->config);

        $copy = new Command\CopyCommand();
        $copy->setConfiguration($this->config);

        $config = new Command\ConfigCommand();
        $config->setConfiguration($this->config);

        $commands = [
            new Command\HelpCommand(),
            new Command\ListCommand(),
            new Command\DumpCommand(),
            $config,
            $copy,
            $doc,
            new Command\ShowCommand(),
            new Command\WtfCommand(),
            new Command\WhereamiCommand(),
            new Command\ThrowUpCommand(),
            new Command\TimeitCommand(),
            new Command\TraceCommand(),
            new Command\ClearCommand(),
            new Command\EditCommand($this->config->getRuntimeDir(false)),
            // new Command\PsyVersionCommand(),
            $sudo,
            $hist,
            new Command\ExitCommand(),
        ];

        // Only add yolo command if UopzReloader is supported
        if (UopzReloader::isSupported()) {
            $yolo = new Command\YoloCommand();
            $commands[] = $yolo;
        }

        return $commands;
    }

    /**
     * @deprecated No longer used internally; matchers are registered via the completion engine
     *
     * @return Matcher\AbstractMatcher[]
     */
    protected function getDefaultMatchers(): array
    {
        return [];
    }

    /**
     * Gets the default command loop listeners.
     *
     * @return array An array of Execution Loop Listener instances
     */
    protected function getDefaultLoopListeners(): array
    {
        $listeners = [];

        if ($inputLogger = $this->config->getInputLogger()) {
            $listeners[] = $inputLogger;
        }

        if (ProcessForker::isSupported() && $this->config->usePcntl()) {
            $listeners[] = new ProcessForker();
        } elseif (SignalHandler::isSupported()) {
            // Only use SignalHandler when process forking is disabled
            // ProcessForker handles SIGINT in the parent process, which is cleaner
            $listeners[] = new SignalHandler();
        }

        if (RunkitReloader::isSupported()) {
            $listeners[] = new RunkitReloader();
        } elseif (UopzReloader::isSupported()) {
            $listeners[] = new UopzReloader();
        }

        if ($executionLogger = $this->config->getExecutionLogger()) {
            $listeners[] = $executionLogger;
        }

        return $listeners;
    }

    /**
     * Enable or disable force-reload mode for code reloaders.
     *
     * Used by the `yolo` command to bypass safety warnings when reloading code.
     */
    public function setForceReload(bool $force): void
    {
        foreach ($this->loopListeners as $listener) {
            if (\method_exists($listener, 'setForceReload')) {
                $listener->setForceReload($force);
            }
        }
    }

    /**
     * Apply live service updates after a runtime configuration change.
     */
    public function applyRuntimeConfigChange(string $key): void
    {
        if (isset($this->output)) {
            switch ($key) {
                case 'colorMode':
                    $decorated = $this->config->getOutputDecorated();
                    $this->output->setDecorated($decorated !== null ? $decorated : !$this->config->outputIsPiped());
                    break;

                case 'verbosity':
                    $this->originalVerbosity = $this->config->getOutputVerbosity();
                    $this->output->setVerbosity($this->originalVerbosity);
                    break;

                case 'theme':
                    if ($this->output instanceof ShellOutput) {
                        $this->output->setTheme($this->config->theme());
                    }
                    break;

                case 'pager':
                    if ($this->output instanceof ShellOutput) {
                        $pager = $this->config->getPager();
                        $this->output->setPager($pager === false ? null : $pager);
                    }
                    break;
            }
        }

        if (isset($this->readline) && $this->readline instanceof InteractiveReadlineInterface) {
            switch ($key) {
                case 'theme':
                    $this->readline->setTheme($this->config->theme());
                    break;

                case 'requireSemicolons':
                    $this->readline->setRequireSemicolons($this->config->requireSemicolons());
                    break;

                case 'useBracketedPaste':
                    $this->readline->setUseBracketedPaste($this->config->useBracketedPaste());
                    break;

                case 'useSyntaxHighlighting':
                    $this->readline->setUseSyntaxHighlighting($this->config->useSyntaxHighlighting());
                    break;

                case 'useSuggestions':
                    $this->readline->setUseSuggestions($this->config->useSuggestions());
                    break;
            }
        }
    }

    /**
     * Add tab completion matchers.
     *
     * @param array $matchers
     */
    public function addMatchers(array $matchers)
    {
        $matchers = $this->deduplicateObjects($matchers, $this->matchers);
        if ($matchers === []) {
            return;
        }

        $this->matchers = \array_merge($this->matchers, $matchers);

        if (isset($this->completionEngine)) {
            $this->addLegacyMatchersToCompletionEngine($matchers);
        }
    }

    /**
     * @deprecated Call `addMatchers` instead
     *
     * @param array $matchers
     */
    public function addTabCompletionMatchers(array $matchers)
    {
        @\trigger_error('`addTabCompletionMatchers` is deprecated; call `addMatchers` instead.', \E_USER_DEPRECATED);

        $this->addMatchers($matchers);
    }

    /**
     * Add completion sources to the completion engine.
     *
     * @internal experimental; API may change before Interactive Readline is stable
     *
     * @param Completion\Source\SourceInterface[] $sources
     */
    public function addCompletionSources(array $sources)
    {
        $existing = isset($this->completionEngine) ? [] : $this->pendingCompletionSources;
        $sources = $this->deduplicateObjects($sources, $existing);
        if ($sources === []) {
            return;
        }

        if (!isset($this->completionEngine)) {
            $this->pendingCompletionSources = \array_merge($this->pendingCompletionSources, $sources);

            return;
        }

        foreach ($sources as $source) {
            $this->completionEngine->addSource($source);
        }
    }

    /**
     * Set the Shell output.
     *
     * @param OutputInterface $output
     */
    public function setOutput(OutputInterface $output)
    {
        $this->output = $output;
        $this->originalVerbosity = $output->getVerbosity();

        if ($output instanceof ShellOutput) {
            $output->setWriteListener(function (): void {
                if ($this->writingLegacySpacer) {
                    return;
                }

                $this->outputWritten = true;
                $this->markLegacyOutputWritten();
            });
        }
    }

    /**
     * Runs PsySH.
     *
     * @param InputInterface|null  $input  An Input instance
     * @param OutputInterface|null $output An Output instance
     *
     * @return int 0 if everything went fine, or an error code
     */
    public function run(?InputInterface $input = null, ?OutputInterface $output = null): int
    {
        // We'll just ignore the input passed in, and set up our own!
        $input = new ArrayInput([]);
        $input->setInteractive($this->config->getInputInteractive());

        if ($output === null) {
            $output = $this->config->getOutput();
        }

        $this->setAutoExit(false);
        $this->setCatchExceptions(false);

        try {
            return parent::run($input, $output);
        } catch (BreakException $e) {
            // BreakException from ProcessForker or exit() - return its exit code
            return $e->getCode();
        } catch (\Throwable $e) {
            $this->writeException($e);
        }

        return 1;
    }

    /**
     * Runs PsySH.
     *
     * @throws \Throwable if thrown via the `throw-up` command
     *
     * @param InputInterface  $input  An Input instance
     * @param OutputInterface $output An Output instance
     *
     * @return int 0 if everything went fine, or an error code
     */
    public function doRun(InputInterface $input, OutputInterface $output): int
    {
        $this->setOutput($output);
        $this->boot($input, $output);
        $this->clearPendingCode();
        $this->warmAutoloader();

        if ($this->config->getInputInteractive()) {
            // @todo should it be possible to have raw output in an interactive run?
            return $this->doInteractiveRun();
        } else {
            return $this->doNonInteractiveRun($this->config->rawOutput());
        }
    }

    /**
     * Run PsySH in interactive mode.
     *
     * Initializes tab completion and readline history, then spins up the
     * execution loop.
     *
     * @throws \Throwable if thrown via the `throw-up` command
     *
     * @return int 0 if everything went fine, or an error code
     */
    private function doInteractiveRun(): int
    {
        if ($this->config->useTabCompletion()) {
            $this->initializeCompletionEngine();
            $this->initializeTabCompletion();
        }

        if ($this->readline instanceof CommandAware) {
            $this->readline->setCommands($this->all());
            $this->commandCompletion[] = $this->readline;
        }

        $this->readline->readHistory();

        $this->output->writeln($this->getHeader());
        $this->writeVersionInfo();
        $this->writeManualUpdateInfo();
        $this->writeStartupMessage();

        try {
            $this->beforeRun();
            $this->loadIncludes();
            $loop = new ExecutionLoopClosure($this);
            $exitCode = $loop->execute();
            $this->afterRun($exitCode ?? 0);

            return $exitCode ?? 0;
        } catch (ThrowUpException $e) {
            throw $e->getPrevious();
        } catch (BreakException $e) {
            // The ProcessForker throws a BreakException to finish the main thread.
            return $e->getCode();
        }
    }

    /**
     * Run PsySH in non-interactive mode.
     *
     * Note that this isn't very useful unless you supply "include" arguments at
     * the command line, or code via stdin.
     *
     * @param bool $rawOutput
     *
     * @return int 0 if everything went fine, or an error code
     */
    private function doNonInteractiveRun(bool $rawOutput): int
    {
        $this->nonInteractive = true;

        // If raw output is enabled (or output is piped) we don't want startup messages.
        if (!$rawOutput && !$this->config->outputIsPiped()) {
            $this->output->writeln($this->getHeader());
            $this->writeVersionInfo();
            $this->writeManualUpdateInfo();
            $this->writeStartupMessage();
        }

        $this->beforeRun();
        $this->loadIncludes();

        // For non-interactive execution, read only from the input buffer or from piped input.
        // Otherwise it'll try to readline and hang, waiting for user input with no indication of
        // what's holding things up.
        if (!empty($this->inputBuffer) || $this->config->inputIsPiped()) {
            $this->getInput(false);
        }

        try {
            if ($this->hasCode()) {
                $ret = $this->execute($this->flushCode());
                $this->writeReturnValue($ret, $rawOutput);
            }
        } catch (BreakException $e) {
            // User called exit() in non-interactive mode
            $this->afterRun($e->getCode());
            $this->nonInteractive = false;

            return $e->getCode();
        }

        $this->afterRun(0);
        $this->nonInteractive = false;

        return 0;
    }

    /**
     * Configures the input and output instances based on the user arguments and options.
     */
    protected function configureIO(InputInterface $input, OutputInterface $output): void
    {
        // @todo overrides via environment variables (or should these happen in config? ... probably config)
        $input->setInteractive($this->config->getInputInteractive());

        if ($this->config->getOutputDecorated() !== null) {
            $output->setDecorated($this->config->getOutputDecorated());
        }

        $output->setVerbosity($this->config->getOutputVerbosity());
    }

    /**
     * Load user-defined includes.
     */
    private function loadIncludes()
    {
        // Load user-defined includes
        $load = function (self $__psysh__) {
            \set_error_handler([$__psysh__, 'handleError']);
            foreach ($__psysh__->getIncludes() as $__psysh_include__) {
                try {
                    include_once $__psysh_include__;
                } catch (\Exception $_e) {
                    $__psysh__->writeException($_e);
                }
            }
            \restore_error_handler();
            unset($__psysh_include__);

            // Override any new local variables with pre-defined scope variables
            \extract($__psysh__->getScopeVariables(false));

            // ... then add the whole mess of variables back.
            $__psysh__->setScopeVariables(\get_defined_vars());
        };

        $load($this);
    }

    /**
     * Read user input.
     *
     * This will continue fetching user input until the code buffer contains
     * valid code.
     *
     * @throws BreakException if user hits Ctrl+D
     *
     * @param bool $interactive
     */
    public function getInput(bool $interactive = true)
    {
        $this->boot();

        while (true) {
            // reset output verbosity (in case it was altered by a subcommand)
            $this->output->setVerbosity($this->originalVerbosity);
            $this->outputWritten = false;

            $input = $this->readline();

            /*
             * Handle Ctrl+D. It behaves differently in different cases:
             *
             *   1) In an expression, like a function or "if" block, clear the input buffer
             *   2) At top-level session, behave like the exit command
             *   3) When non-interactive, return, because that's the end of stdin
             */
            if ($input === false) {
                if (!$interactive) {
                    return;
                }

                $this->output->writeln('');

                throw new BreakException('Ctrl+D');
            }

            // handle empty input
            if (\trim($input) === '') {
                $this->notifyOutputWritten();
                continue;
            }

            if (!$this->hasCode()) {
                $this->writeLegacyInputSpacer();
            }

            $input = $this->onInput($input);

            if ($this->hasCommand($input) && !$this->inputInOpenStringOrComment($input)) {
                $this->addHistory($input);
                $outputPositions = $this->captureOutputStreamPositions();
                $this->writePhpCommandCollisionHint($input);
                $this->runCommand($input);
                if (!$this->outputWritten && $this->outputWasWrittenSince($outputPositions)) {
                    $this->outputWritten = true;
                    $this->markLegacyOutputWritten();
                }
                $this->notifyOutputWritten();

                if ($interactive && $this->hasValidCode()) {
                    return;
                }

                continue;
            }

            $this->addCode($input);
            if ($interactive) {
                return;
            }
        }
    }

    /**
     * Run execution loop listeners before the shell session.
     */
    protected function beforeRun()
    {
        foreach ($this->loopListeners as $listener) {
            if ($listener instanceof OutputAware) {
                $listener->setOutput($this->output);
            }
        }

        foreach ($this->loopListeners as $listener) {
            $listener->beforeRun($this);
        }
    }

    /**
     * Run execution loop listeners at the start of each loop.
     */
    public function beforeLoop()
    {
        $this->outputWritten = false;

        foreach ($this->loopListeners as $listener) {
            $listener->beforeLoop($this);
        }
    }

    /**
     * Run execution loop listeners on user input.
     *
     * @param string $input
     */
    public function onInput(string $input): string
    {
        foreach ($this->loopListeners as $listeners) {
            if (($return = $listeners->onInput($this, $input)) !== null) {
                $input = $return;
            }
        }

        return $input;
    }

    /**
     * Run execution loop listeners on code to be executed.
     *
     * @param string $code
     */
    public function onExecute(string $code): string
    {
        $this->errorReporting = \error_reporting();
        $this->enableInteractiveSignalCharsIfNeeded();

        foreach ($this->loopListeners as $listener) {
            if (($return = $listener->onExecute($this, $code)) !== null) {
                $code = $return;
            }
        }

        $output = $this->output;
        if ($output instanceof ConsoleOutput) {
            $output = $output->getErrorOutput();
        }

        $output->writeln(\sprintf('<whisper>%s</whisper>', OutputFormatter::escape($code)), ConsoleOutput::VERBOSITY_DEBUG);

        return $code;
    }

    /**
     * Run execution loop listeners after each loop.
     */
    public function afterLoop()
    {
        $this->disableInteractiveSignalCharsIfNeeded();

        foreach (\array_reverse($this->loopListeners) as $listener) {
            $listener->afterLoop($this);
        }

        $this->notifyOutputWritten();
    }

    /**
     * Report to the interactive readline whether visible output was written.
     */
    private function notifyOutputWritten(): void
    {
        if ($this->readline instanceof InteractiveReadlineInterface) {
            $this->readline->setOutputWritten($this->outputWritten);
        }
    }

    /**
     * Capture write positions for output streams not covered by explicit write listeners.
     *
     * @return array<int, int>|null
     */
    private function captureOutputStreamPositions(): ?array
    {
        $outputs = [$this->output];

        if ($this->output instanceof ConsoleOutput) {
            $outputs[] = $this->output->getErrorOutput();
        }

        $positions = [];

        foreach ($outputs as $output) {
            if (!$output instanceof StreamOutput) {
                continue;
            }

            $stream = $output->getStream();
            if (!\is_resource($stream) || \get_resource_type($stream) !== 'stream') {
                continue;
            }

            $position = @\ftell($stream);
            if (!\is_int($position)) {
                continue;
            }

            $positions[(int) $stream] = $position;
        }

        return $positions !== [] ? $positions : null;
    }

    /**
     * Determine whether a command wrote output based on fallback stream movement.
     *
     * This covers outputs that don't report writes explicitly, such as plain
     * StreamOutput instances and stderr writes routed around ShellOutput.
     * If stream positions are unavailable, assume output may have been written
     * to avoid false "no output" frame continuation.
     *
     * @param array<int, int>|null $before
     */
    private function outputWasWrittenSince(?array $before): bool
    {
        if ($before === null) {
            return true;
        }

        $after = $this->captureOutputStreamPositions();
        if ($after === null) {
            return true;
        }

        foreach ($before as $streamId => $position) {
            if (($after[$streamId] ?? $position) > $position) {
                return true;
            }
        }

        foreach ($after as $streamId => $position) {
            if (!isset($before[$streamId]) && $position > 0) {
                return true;
            }
        }

        return false;
    }

    /**
     * Run execution loop listers after the shell session.
     *
     * @param int $exitCode Exit code from the execution loop
     */
    protected function afterRun(int $exitCode = 0)
    {
        $this->disableInteractiveSignalCharsIfNeeded();

        foreach (\array_reverse($this->loopListeners) as $listener) {
            $listener->afterRun($this, $exitCode);
        }
    }

    /**
     * Enable terminal signal chars during code execution when no SIGINT listener is active.
     *
     * Interactive readline raw mode disables terminal-generated SIGINT by default.
     * When ProcessForker/SignalHandler are unavailable, we temporarily re-enable
     * signal chars so Ctrl-C can still interrupt long-running code.
     */
    private function enableInteractiveSignalCharsIfNeeded(): void
    {
        if (
            $this->interactiveSignalCharsEnabled
            || $this->nonInteractive
            || !($this->readline instanceof InteractiveReadlineInterface)
            || $this->hasSigintExecutionListener()
            || !Tty::supportsStty()
        ) {
            return;
        }

        @\shell_exec('stty isig 2>/dev/null');
        $this->interactiveSignalCharsEnabled = true;
    }

    /**
     * Restore prompt-time terminal signal behavior after execution.
     */
    private function disableInteractiveSignalCharsIfNeeded(): void
    {
        if (!$this->interactiveSignalCharsEnabled) {
            return;
        }

        @\shell_exec('stty -isig 2>/dev/null');
        $this->interactiveSignalCharsEnabled = false;
    }

    /**
     * Check whether any loop listener handles SIGINT during execution.
     */
    private function hasSigintExecutionListener(): bool
    {
        foreach ($this->loopListeners as $listener) {
            if ($listener instanceof ProcessForker || $listener instanceof SignalHandler) {
                return true;
            }
        }

        return false;
    }

    /**
     * Set the variables currently in scope.
     *
     * @param array $vars
     */
    public function setScopeVariables(array $vars)
    {
        $this->context->setAll($vars);
    }

    /**
     * Return the set of variables currently in scope.
     *
     * @param bool $includeBoundObject Pass false to exclude 'this'. If you're
     *                                 passing the scope variables to `extract`
     *                                 you _must_ exclude 'this'
     *
     * @return array Associative array of scope variables
     */
    public function getScopeVariables(bool $includeBoundObject = true): array
    {
        $vars = $this->context->getAll();

        if (!$includeBoundObject) {
            unset($vars['this']);
        }

        return $vars;
    }

    /**
     * Return the set of magic variables currently in scope.
     *
     * @param bool $includeBoundObject Pass false to exclude 'this'. If you're
     *                                 passing the scope variables to `extract`
     *                                 you _must_ exclude 'this'
     *
     * @return array Associative array of magic scope variables
     */
    public function getSpecialScopeVariables(bool $includeBoundObject = true): array
    {
        $vars = $this->context->getSpecialVariables();

        if (!$includeBoundObject) {
            unset($vars['this']);
        }

        return $vars;
    }

    /**
     * Return the set of variables currently in scope which differ from the
     * values passed as $currentVars.
     *
     * This is used inside the Execution Loop Closure to pick up scope variable
     * changes made by commands while the loop is running.
     *
     * @param array $currentVars
     *
     * @return array Associative array of scope variables which differ from $currentVars
     */
    public function getScopeVariablesDiff(array $currentVars): array
    {
        $newVars = [];

        foreach ($this->getScopeVariables(false) as $key => $value) {
            if (!\array_key_exists($key, $currentVars) || $currentVars[$key] !== $value) {
                $newVars[$key] = $value;
            }
        }

        return $newVars;
    }

    /**
     * Get the set of unused command-scope variable names.
     *
     * @return array Array of unused variable names
     */
    public function getUnusedCommandScopeVariableNames(): array
    {
        return $this->context->getUnusedCommandScopeVariableNames();
    }

    /**
     * Get the set of variable names currently in scope.
     *
     * @return array Array of variable names
     */
    public function getScopeVariableNames(): array
    {
        return \array_keys($this->context->getAll());
    }

    /**
     * Get a scope variable value by name.
     *
     * @param string $name
     *
     * @return mixed
     */
    public function getScopeVariable(string $name)
    {
        return $this->context->get($name);
    }

    /**
     * Set the bound object ($this variable) for the interactive shell.
     *
     * @param object|null $boundObject
     */
    public function setBoundObject($boundObject)
    {
        $this->context->setBoundObject($boundObject);
    }

    /**
     * Get the bound object ($this variable) for the interactive shell.
     *
     * @return object|null
     */
    public function getBoundObject()
    {
        return $this->context->getBoundObject();
    }

    /**
     * Set the bound class (self) for the interactive shell.
     *
     * @param string|null $boundClass
     */
    public function setBoundClass($boundClass)
    {
        $this->context->setBoundClass($boundClass);
    }

    /**
     * Get the bound class (self) for the interactive shell.
     *
     * @return string|null
     */
    public function getBoundClass()
    {
        return $this->context->getBoundClass();
    }

    /**
     * Add includes, to be parsed and executed before running the interactive shell.
     *
     * @param array $includes
     */
    public function setIncludes(array $includes = [])
    {
        $this->includes = $includes;
    }

    /**
     * Get PHP files to be parsed and executed before running the interactive shell.
     *
     * @return string[]
     */
    public function getIncludes(): array
    {
        return \array_merge($this->config->getDefaultIncludes(), $this->includes);
    }

    /**
     * Check whether this shell's code buffer contains code.
     *
     * @return bool True if the code buffer contains code
     */
    public function hasCode(): bool
    {
        return $this->pendingInput->hasCode();
    }

    /**
     * Check whether the code in this shell's code buffer is valid.
     *
     * If the code is valid, the code buffer should be flushed and evaluated.
     *
     * @return bool True if the code buffer content is valid
     */
    protected function hasValidCode(): bool
    {
        return $this->pendingInput->hasValidCode();
    }

    /**
     * Add code to the code buffer.
     *
     * @param string $code
     * @param bool   $silent
     */
    public function addCode(string $code, bool $silent = false)
    {
        $this->appendCode($code, $silent);
    }

    /**
     * Add code to the pending buffer or active legacy continuation buffer.
     *
     * @param string $code
     * @param bool   $silent
     * @param bool   $allowLegacyBufferAppend
     */
    private function appendCode(string $code, bool $silent = false, bool $allowLegacyBufferAppend = true): void
    {
        $this->boot();

        if ($allowLegacyBufferAppend && $this->readline instanceof LegacyReadline && $this->readline->hasBuffer()) {
            $this->readline->append($code);

            return;
        }

        try {
            $this->pendingInput->appendLine($code, $silent);
            $cleanedCode = $this->cleaner->clean($this->pendingInput->getPendingCodeBuffer(), $this->config->requireSemicolons());
            $this->pendingInput->setPendingCode($cleanedCode);

            if (!$silent && $cleanedCode !== false) {
                $this->suppressReturnValue = $this->shouldSuppressReturnValue();
                $this->writeCleanerMessages();
            }
        } catch (\Throwable $e) {
            // Add failed pending code blocks to the readline history.
            $this->addPendingCodeBufferToHistory();

            throw $e;
        }
    }

    /**
     * Check whether the current code buffer ends with an unnecessary semicolon.
     *
     * @see Configuration::semicolonsSuppressReturn()
     */
    private function shouldSuppressReturnValue(): bool
    {
        if ($this->config->semicolonsSuppressReturn() === false) {
            return false;
        }

        $tokens = @\token_get_all('<?php '.\implode(\PHP_EOL, $this->pendingInput->getPendingCodeBuffer()));
        [$lastToken, $index] = $this->lastNonCommentToken($tokens);

        if ($lastToken !== ';') {
            return false;
        }

        $requireDouble = $this->config->semicolonsSuppressReturn() === Configuration::SEMICOLONS_SUPPRESS_RETURN_DOUBLE
            || $this->config->requireSemicolons();

        if (!$requireDouble) {
            // When semicolons are optional, a single ; is unnecessary
            return true;
        }

        // Require a double semicolon (`;;`) to suppress
        return $index !== null && $this->lastNonCommentToken($tokens, $index - 1)[0] === ';';
    }

    /**
     * Get the last non-comment token from a tokenized PHP snippet.
     *
     * @param array $tokens Token array from token_get_all()
     *
     * @return array Token and index pair: [token, index] or [null, null]
     */
    private function lastNonCommentToken(array $tokens, ?int $offset = null): array
    {
        $offset ??= \count($tokens) - 1;

        for ($i = $offset; $i >= 0; $i--) {
            $token = $tokens[$i];

            if (\is_array($token) && \in_array($token[0], [\T_WHITESPACE, \T_COMMENT, \T_DOC_COMMENT, \T_OPEN_TAG], true)) {
                continue;
            }

            return [$token, $i];
        }

        return [null, null];
    }

    /**
     * Check whether the pending code buffer plus current input is in an open string or comment.
     */
    private function inputInOpenStringOrComment(string $input): bool
    {
        if (!$this->hasCode()) {
            return false;
        }

        $code = $this->pendingInput->getPendingCodeBuffer();
        $code[] = $input;
        $tokens = @\token_get_all('<?php '.\implode(\PHP_EOL, $code));
        $last = \array_pop($tokens);

        return $last === '"' || $last === '`' ||
            (\is_array($last) && \in_array($last[0], [\T_ENCAPSED_AND_WHITESPACE, \T_START_HEREDOC, \T_COMMENT], true));
    }

    /**
     * Set the pending code buffer.
     *
     * This is mostly used by `Shell::execute`. Any existing code in the input
     * buffer is pushed onto a stack and will come back after this new code is
     * executed.
     *
     * @throws \InvalidArgumentException if $code isn't a complete statement
     *
     * @param string $code
     * @param bool   $silent
     */
    private function setCode(string $code, bool $silent = false)
    {
        if ($this->hasCode()) {
            $this->pendingInput->pushCurrentCode();
        }

        $this->clearPendingCode();
        try {
            $this->appendCode($code, $silent, false);
        } catch (\Throwable $e) {
            $this->popCodeStack();

            throw $e;
        }

        if (!$this->hasValidCode()) {
            $this->popCodeStack();

            throw new \InvalidArgumentException('Unexpected end of input');
        }
    }

    /**
     * Get the current code buffer.
     *
     * This is useful for callers which still inspect the shell's pending code.
     *
     * @return string[]
     *
     * @deprecated pending input inspection is being removed from Shell internals
     */
    public function getCodeBuffer(): array
    {
        return $this->getPendingCodeBuffer();
    }

    /**
     * Get the current executable pending code buffer.
     *
     * @return string[]
     */
    public function getPendingCodeBuffer(): array
    {
        return $this->pendingInput->getPendingCodeBuffer();
    }

    /**
     * Run a Psy Shell command given the user input.
     *
     * @throws \InvalidArgumentException if the input is not a valid command
     *
     * @param string $input User input string
     *
     * @return mixed Who knows?
     */
    protected function runCommand(string $input)
    {
        $command = $this->getCommand($input);

        if (empty($command)) {
            throw new \InvalidArgumentException('Command not found: '.$input);
        }

        if ($logger = $this->config->getLogger()) {
            $logger->logCommand($input);
        }

        $input = new ShellInput(\str_replace('\\', '\\\\', \rtrim($input, " \t\n\r\0\x0B;")));

        if (!$input->hasParameterOption(['--help', '-h'])) {
            try {
                return $command->run($input, $this->output);
            } catch (\Exception $e) {
                if (!self::needsInputHelp($e)) {
                    throw $e;
                }

                $this->writeException($e);

                $this->writeSeparator($this->output);
            }
        }

        $helpCommand = $this->get('help');
        if (!$helpCommand instanceof Command\HelpCommand) {
            throw new RuntimeException('Invalid help command instance');
        }
        $helpCommand->setCommand($command);
        $helpCommand->setCommandInput($input);

        return $helpCommand->run(new StringInput(''), $this->output);
    }

    /**
     * Check whether a given input error would benefit from --help.
     *
     * @return bool
     */
    private static function needsInputHelp(\Exception $e): bool
    {
        if (!($e instanceof \RuntimeException || $e instanceof SymfonyConsoleException)) {
            return false;
        }

        $inputErrors = [
            'Not enough arguments',
            'option does not accept a value',
            'option does not exist',
            'option requires a value',
        ];

        $msg = $e->getMessage();
        foreach ($inputErrors as $errorMsg) {
            if (\strpos($msg, $errorMsg) !== false) {
                return true;
            }
        }

        return false;
    }

    /**
     * Whisper messages from CodeCleaner passes.
     */
    private function writeCleanerMessages(): void
    {
        if (!isset($this->output)) {
            return;
        }

        $output = $this->output;
        if ($output instanceof ConsoleOutput) {
            $output = $output->getErrorOutput();
        }

        foreach ($this->cleaner->getMessages() as $message) {
            $output->writeln(\sprintf('<whisper>%s</whisper>', OutputFormatter::escape($message)));
        }
    }

    /**
     * Reset the current pending code buffer.
     *
     * This should be run after evaluating user input, catching exceptions, or
     * on demand by commands such as BufferCommand.
     *
     * @deprecated pending input reset is being removed from Shell internals
     */
    public function resetCodeBuffer()
    {
        $this->clearPendingCode();
    }

    /**
     * Clear the current executable pending code buffer.
     */
    public function clearPendingCodeBuffer(): void
    {
        $this->clearPendingCode();
    }

    /**
     * Inject input into the input buffer.
     *
     * This is useful for commands which want to replay history.
     *
     * @param string|array $input
     * @param bool         $silent
     */
    public function addInput($input, bool $silent = false)
    {
        foreach ((array) $input as $line) {
            $this->inputBuffer[] = $silent ? new SilentInput($line) : $line;
        }
    }

    /**
     * Flush the current executable pending code buffer.
     *
     * If the code buffer is valid, resets the code buffer and returns the
     * current code.
     *
     * @return string|null PHP code buffer contents
     */
    public function flushCode()
    {
        if ($this->hasValidCode()) {
            $this->addPendingCodeBufferToHistory();
            $code = $this->pendingInput->getPendingCode();
            $this->popCodeStack();

            return $code;
        }

        return null;
    }

    /**
     * Reset pending code and restore any code pushed during `execute` calls.
     */
    private function popCodeStack()
    {
        $this->pendingInput->restorePreviousCode();
    }

    /**
     * (Possibly) add a line to the readline history.
     *
     * Like Bash, if the line starts with a space character, it will be omitted
     * from history. Note that an entire block multi-line code input will be
     * omitted iff the first line begins with a space.
     *
     * Additionally, if a line is "silent", i.e. it was initially added with the
     * silent flag, it will also be omitted.
     *
     * @param string|SilentInput $line
     */
    private function addHistory($line)
    {
        if ($line instanceof SilentInput) {
            return;
        }

        // Skip empty lines and lines starting with a space
        if (\trim($line) !== '' && \substr($line, 0, 1) !== ' ') {
            $this->readline->addHistory($line);
        }
    }

    /**
     * Filter silent input from code buffer, write the rest to readline history.
     */
    private function addPendingCodeBufferToHistory()
    {
        $codeBuffer = \array_filter($this->pendingInput->getPendingCodeBuffer(), fn ($line) => !$line instanceof SilentInput);

        $this->addHistory(\implode("\n", $codeBuffer));
    }

    /**
     * Clear the shell's pending execution state.
     */
    private function clearPendingCode(): void
    {
        $this->pendingInput->clear();
    }

    /**
     * Get the current evaluation scope namespace.
     *
     * @see CodeCleaner::getNamespace
     *
     * @return string|null Current code namespace
     */
    public function getNamespace()
    {
        $this->boot();

        if ($namespace = $this->cleaner->getNamespace()) {
            return \implode('\\', $namespace);
        }

        return null;
    }

    /**
     * Write a string to stdout.
     *
     * This is used by the shell loop for rendering output from evaluated code.
     *
     * @param string $out
     * @param int    $phase Output buffering phase
     *
     * @return string Empty string
     */
    public function writeStdout(string $out, int $phase = \PHP_OUTPUT_HANDLER_END): string
    {
        if ($phase & \PHP_OUTPUT_HANDLER_START) {
            if ($this->output instanceof ShellOutput) {
                $this->output->startPaging();
            }
        }

        $isCleaning = $phase & \PHP_OUTPUT_HANDLER_CLEAN;

        // Incremental flush
        if ($out !== '' && !$isCleaning) {
            $this->markLegacyOutputWritten();
            $this->output->write($out, false, OutputInterface::OUTPUT_RAW);
            $this->outputWantsNewline = (\substr($out, -1) !== "\n");
            $this->stdoutBuffer .= $out;
            $this->outputWritten = true;
        }

        // Output buffering is done!
        if ($phase & \PHP_OUTPUT_HANDLER_END) {
            // Write an extra newline if stdout didn't end with one
            if ($this->outputWantsNewline) {
                if (!$this->config->rawOutput() && !$this->config->outputIsPiped()) {
                    $this->output->writeln(\sprintf('<whisper>%s</whisper>', $this->config->useUnicode() ? '⏎' : '\\n'));
                } else {
                    $this->output->writeln('');
                }
                $this->outputWantsNewline = false;
            }

            // Save the stdout buffer as $__out
            if ($this->stdoutBuffer !== '') {
                $this->context->setLastStdout($this->stdoutBuffer);
                $this->stdoutBuffer = '';
            }

            if ($this->output instanceof ShellOutput) {
                $this->output->stopPaging();
            }
        }

        return '';
    }

    /**
     * Write a return value to stdout.
     *
     * The return value is formatted or pretty-printed, and rendered in a
     * visibly distinct manner (in this case, as cyan).
     *
     * @see self::presentValue
     *
     * @param mixed $ret
     * @param bool  $rawOutput Write raw var_export-style values
     */
    public function writeReturnValue($ret, bool $rawOutput = false)
    {
        $this->lastExecSuccess = true;

        if ($ret instanceof NoReturnValue) {
            $this->suppressReturnValue = false;

            return;
        }

        $this->context->setReturnValue($ret);

        // Don't display the return value, but $_ is still captured above.
        if ($this->suppressReturnValue) {
            $this->suppressReturnValue = false;

            return;
        }

        if ($rawOutput) {
            $formatted = \var_export($ret, true);
        } else {
            $prompt = $this->config->theme()->returnValue();
            $indent = \str_repeat(' ', \strlen($prompt));
            $formatted = $this->presentValue($ret);
            $formatter = $this->output->getFormatter();
            $formattedPrompt = ($formatter->hasStyle('whisper') && $formatter->isDecorated())
                ? $formatter->getStyle('whisper')->apply($prompt)
                : $prompt;

            $formatted = $formattedPrompt.\str_replace(\PHP_EOL, \PHP_EOL.$indent, $formatted);
        }

        $this->outputWritten = true;
        $this->markLegacyOutputWritten();

        if ($this->output instanceof ShellOutput) {
            $this->output->page($formatted, OutputInterface::OUTPUT_RAW);
        } else {
            $this->output->writeln($formatted, OutputInterface::OUTPUT_RAW);
        }
    }

    /**
     * Renders a caught Exception or Error.
     *
     * Exceptions are formatted according to severity. ErrorExceptions which were
     * warnings or Strict errors aren't rendered as harshly as real errors.
     *
     * Stores $e as the last Exception in the Shell Context.
     *
     * @param \Throwable $e An exception or error instance
     */
    public function writeException(\Throwable $e)
    {
        // No need to write the break exception during a non-interactive run.
        if ($e instanceof BreakException && $this->nonInteractive) {
            $this->clearPendingCode();

            return;
        }

        // Break exceptions don't count :)
        if (!$e instanceof BreakException) {
            $this->lastExecSuccess = false;
            $this->context->setLastException($e);
            $this->outputWritten = true;
        }

        $this->markLegacyOutputWritten();

        $output = $this->output;
        if ($output instanceof ConsoleOutput) {
            $output = $output->getErrorOutput();
        }

        $this->writeExceptionHeader($output, $e);
        if ($e instanceof BreakException) {
            $this->writeSpacer($output);
        }

        // Include an exception trace (as long as this isn't a BreakException).
        if (!$e instanceof BreakException && $output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
            $trace = TraceFormatter::formatTrace($e);
            if (\count($trace) !== 0) {
                $this->writeSeparator($output);
                $output->write($trace, true);
            }
        }

        $this->clearPendingCode();
    }

    /**
     * Check whether the last exec was successful.
     *
     * Returns true if a return value was logged rather than an exception.
     */
    public function getLastExecSuccess(): bool
    {
        return $this->lastExecSuccess;
    }

    /**
     * Check whether the shell is using a compact theme.
     */
    public function isCompactTheme(): bool
    {
        return $this->config->theme()->compact();
    }

    /**
     * Write a formatted exception header with optional details and compact-aware spacing.
     */
    public function writeExceptionHeader(OutputInterface $output, \Throwable $e): void
    {
        $output->writeln($this->formatException($e));

        if ($details = $this->formatExceptionDetails($e)) {
            $output->writeln($details, OutputInterface::OUTPUT_RAW);
        }
    }

    /**
     * Helper for formatting an exception or error for writeException().
     *
     * @todo extract this to somewhere it makes more sense
     *
     * @param \Throwable $e
     */
    public function formatException(\Throwable $e): string
    {
        $indent = $this->config->theme()->compact() ? '' : '  ';

        if ($e instanceof BreakException) {
            return \sprintf('%s<fg=black;bg=cyan> INFO </> %s.', $indent, \rtrim($e->getRawMessage(), '.'));
        } elseif ($e instanceof InterruptException) {
            return \sprintf('%s<warning> INTERRUPT </warning> %s.', $indent, $e->getRawMessage());
        } elseif ($e instanceof PsyException) {
            $message = $e->getLine() > 1
                ? \sprintf('%s in %s on line %d', $e->getRawMessage(), $e->getFile(), $e->getLine())
                : \sprintf('%s in %s', $e->getRawMessage(), $e->getFile());

            $messageLabel = \strtoupper($this->getMessageLabel($e));
        } else {
            $message = $e->getMessage();
            $messageLabel = $this->getMessageLabel($e);
        }

        $message = \preg_replace(
            [
                "#(?:[A-Za-z]:)?[\\\\/][^\\r\\n]*?[\\\\/]src[\\\\/]Execution(?:Loop)?Closure\\.php\\(\\d+\\) : eval\\(\\)'d code#",
                "#\\bsrc[\\\\/]Execution(?:Loop)?Closure\\.php\\(\\d+\\) : eval\\(\\)'d code#",
            ],
            "eval()'d code",
            $message
        );

        $message = \str_replace(" in eval()'d code", '', $message);
        $message = \trim($message);

        // Ensures the given string ends with punctuation...
        if (!empty($message) && !\in_array(\substr($message, -1), ['.', '?', '!', ':'])) {
            $message = "$message.";
        }

        // Ensures the given message only contains relative paths...
        $message = \str_replace(\getcwd().\DIRECTORY_SEPARATOR, '', $message);

        $severity = ($e instanceof \ErrorException) ? $this->getSeverity($e) : 'error';

        return \sprintf('%s<%s> %s </%s> %s', $indent, $severity, $messageLabel, $severity, OutputFormatter::escape($message));
    }

    /**
     * Format exception details (if provided) for display.
     */
    protected function formatExceptionDetails(\Throwable $e): ?string
    {
        $formatter = $this->config->getExceptionDetails();
        if ($formatter === null) {
            return null;
        }

        try {
            $details = $formatter($e);
        } catch (\Throwable $_e) {
            return null;
        }

        if ($details === null) {
            return null;
        }

        $rendered = $this->presentValue($details);
        $compact = $this->config->theme()->compact();
        $indent = $compact ? '  ' : '    ';
        $prefix = $compact ? '' : \PHP_EOL;

        return $prefix.\implode(\PHP_EOL, \array_map(static function ($line) use ($indent) {
            return $indent.$line;
        }, \explode(\PHP_EOL, $rendered)));
    }

    /**
     * Write a single blank spacer line in non-compact mode.
     */
    public function writeSpacer(OutputInterface $output): void
    {
        if (!$this->isCompactTheme()) {
            $output->writeln('');
        }
    }

    /**
     * Write a separator line with compact-aware spacing.
     */
    public function writeSeparator(OutputInterface $output): void
    {
        $this->writeSpacer($output);
        $output->writeln('--');
        $this->writeSpacer($output);
    }

    /**
     * Check whether the shell is using legacy readline with non-compact spacing.
     */
    private function usesLegacySpacerLayout(): bool
    {
        return $this->readline instanceof LegacyReadline && !$this->isCompactTheme();
    }

    /**
     * Write a single blank spacer line for legacy readline.
     */
    private function writeLegacySpacer(): void
    {
        if (!$this->usesLegacySpacerLayout() || $this->writingLegacySpacer) {
            return;
        }

        $this->writingLegacySpacer = true;

        try {
            $this->output->writeln('');
        } finally {
            $this->writingLegacySpacer = false;
        }
    }

    /**
     * Write the spacer separating the previous output block from the next prompt.
     */
    private function writeLegacyPromptSpacer(): void
    {
        if (!$this->legacyNeedsPromptSpacer) {
            return;
        }

        $this->writeLegacySpacer();
        $this->legacyNeedsPromptSpacer = false;
    }

    /**
     * Write the spacer separating submitted input from subsequent output.
     */
    private function writeLegacyInputSpacer(): void
    {
        $this->writeLegacySpacer();
        $this->legacyNeedsPromptSpacer = false;
    }

    /**
     * Mark that visible output was written and the next prompt needs spacing.
     */
    private function markLegacyOutputWritten(): void
    {
        if ($this->usesLegacySpacerLayout()) {
            $this->legacyNeedsPromptSpacer = true;
        }
    }

    /**
     * Helper for getting an output style for the given ErrorException's level.
     *
     * @param \ErrorException $e
     */
    protected function getSeverity(\ErrorException $e): string
    {
        $severity = $e->getSeverity();
        if ($severity & \error_reporting()) {
            switch ($severity) {
                case \E_WARNING:
                case \E_NOTICE:
                case \E_CORE_WARNING:
                case \E_COMPILE_WARNING:
                case \E_USER_WARNING:
                case \E_USER_NOTICE:
                case \E_USER_DEPRECATED:
                case \E_DEPRECATED:
                    return 'warning';

                default:
                    if ((\PHP_VERSION_ID < 80400) && $severity === \E_STRICT) {
                        return 'warning';
                    }

                    return 'error';
            }
        } else {
            // Since this is below the user's reporting threshold, it's always going to be a warning.
            return 'warning';
        }
    }

    /**
     * Helper for getting an output style for the given ErrorException's level.
     *
     * @param \Throwable $e
     */
    protected function getMessageLabel(\Throwable $e): string
    {
        if ($e instanceof \ErrorException) {
            $severity = $e->getSeverity();

            if ($severity & \error_reporting()) {
                switch ($severity) {
                    case \E_WARNING:
                        return 'Warning';
                    case \E_NOTICE:
                        return 'Notice';
                    case \E_CORE_WARNING:
                        return 'Core Warning';
                    case \E_COMPILE_WARNING:
                        return 'Compile Warning';
                    case \E_USER_WARNING:
                        return 'User Warning';
                    case \E_USER_NOTICE:
                        return 'User Notice';
                    case \E_USER_DEPRECATED:
                        return 'User Deprecated';
                    case \E_DEPRECATED:
                        return 'Deprecated';
                    default:
                        if ((\PHP_VERSION_ID < 80400) && $severity === \E_STRICT) {
                            return 'Strict';
                        }
                }
            }
        }

        if ($e instanceof PsyException || $e instanceof SymfonyConsoleException) {
            $exceptionShortName = (new \ReflectionClass($e))->getShortName();
            $typeParts = \preg_split('/(?=[A-Z])/', $exceptionShortName);

            switch ($exceptionShortName) {
                case 'RuntimeException':
                case 'LogicException':
                    // These ones look weird without 'Exception'
                    break;
                default:
                    if (\end($typeParts) === 'Exception') {
                        \array_pop($typeParts);
                    }
                    break;
            }

            return \trim(\strtoupper(\implode(' ', $typeParts)));
        }

        return \get_class($e);
    }

    /**
     * Execute code in the shell execution context.
     *
     * @param string $code
     * @param bool   $throwExceptions
     *
     * @return mixed
     */
    public function execute(string $code, bool $throwExceptions = false)
    {
        $this->boot();

        $this->setCode($code, true);

        if ($logger = $this->config->getLogger()) {
            $logger->logExecute($code);
        }

        $closure = new ExecutionClosure($this);

        if ($throwExceptions) {
            return $closure->execute();
        }

        try {
            return $closure->execute();
        } catch (BreakException $_e) {
            // Re-throw BreakException so it can propagate exit codes
            throw $_e;
        } catch (\Throwable $_e) {
            $this->writeException($_e);
        }
    }

    /**
     * Helper for throwing an ErrorException.
     *
     * This allows us to:
     *
     *     set_error_handler([$psysh, 'handleError']);
     *
     * Unlike ErrorException::throwException, this error handler respects error
     * levels; i.e. it logs warnings and notices, but doesn't throw exceptions.
     * This should probably only be used in the inner execution loop of the
     * shell, as most of the time a thrown exception is much more useful.
     *
     * If the error type matches the `errorLoggingLevel` config, it will be
     * logged as well, regardless of the `error_reporting` level.
     *
     * @see \Psy\Exception\ErrorException::throwException
     * @see \Psy\Shell::writeException
     *
     * @throws \Psy\Exception\ErrorException depending on the error level
     *
     * @param int    $errno   Error type
     * @param string $errstr  Message
     * @param string $errfile Filename
     * @param int    $errline Line number
     */
    public function handleError($errno, $errstr, $errfile, $errline)
    {
        // This is an error worth throwing.
        //
        // n.b. Technically we can't handle all of these in userland code, but
        // we'll list 'em all for good measure
        if ($errno & (\E_ERROR | \E_PARSE | \E_CORE_ERROR | \E_COMPILE_ERROR | \E_USER_ERROR | \E_RECOVERABLE_ERROR)) {
            ErrorException::throwException($errno, $errstr, $errfile, $errline);
        }

        // When errors are suppressed, the error_reporting value will differ
        // from when we started executing. In that case, we won't log errors.
        $errorsSuppressed = $this->errorReporting !== null && $this->errorReporting !== \error_reporting();

        // Otherwise log it and continue.
        if ($errno & \error_reporting() || (!$errorsSuppressed && ($errno & $this->config->errorLoggingLevel()))) {
            $this->writeException(new ErrorException($errstr, 0, $errno, $errfile, $errline));
        }
    }

    /**
     * Format a value for display.
     *
     * @see Presenter::present
     *
     * @param mixed $val
     *
     * @return string Formatted value
     */
    protected function presentValue($val): string
    {
        return $this->config->getPresenter()->present($val, null, Presenter::RAW);
    }

    /**
     * Get a command (if one exists) for the current input string.
     *
     * @param string $input
     *
     * @return BaseCommand|null
     */
    protected function getCommand(string $input)
    {
        $input = new StringInput($input);
        if ($name = $input->getFirstArgument()) {
            return $this->get($name);
        }

        return null;
    }

    /**
     * Check whether a command is set for the current input string.
     *
     * @param string $input
     *
     * @return bool True if the shell has a command for the given input
     */
    public function hasCommand(string $input): bool
    {
        $name = $this->extractCommandName($input);

        return $name !== null && $this->has($name);
    }

    /**
     * Extract the command name (first word) from input.
     */
    private function extractCommandName(string $input): ?string
    {
        if (\preg_match('/([^\s]+?)(?:\s|$)/A', \ltrim($input), $match)) {
            return $match[1];
        }

        return null;
    }

    /**
     * Write a hint if the input collides with a callable PHP function.
     */
    private function writePhpCommandCollisionHint(string $input): void
    {
        $function = $this->getPhpCommandCollisionFunction($input);
        if ($function === null) {
            return;
        }

        $label = OutputFormatter::escape($function.'()');
        $this->output->writeln(\sprintf(
            '<whisper>Input also matches PHP function %s; prefix with ";" to execute PHP instead.</whisper>',
            $label
        ));
    }

    /**
     * Return the callable PHP function name when a command input also resolves as a direct PHP call.
     */
    private function getPhpCommandCollisionFunction(string $input): ?string
    {
        $commandName = $this->extractCommandName($input);
        if ($commandName === null || $this->cleaner === null) {
            return null;
        }

        return $this->cleaner->getCallableFunctionForInput($input, $commandName);
    }

    /**
     * Get the current input prompt.
     *
     * @return string|null
     */
    protected function getPrompt()
    {
        if ($this->output->isQuiet()) {
            return null;
        }

        return $this->config->theme()->prompt();
    }

    /**
     * Read a line of user input.
     *
     * This will return a line from the input buffer (if any exist). Otherwise,
     * it will ask the user for input.
     *
     * If readline is enabled, this delegates to readline. Otherwise, it's an
     * ugly `fgets` call.
     *
     * @param bool $interactive
     *
     * @return string|false One line of user input
     */
    protected function readline(bool $interactive = true)
    {
        $prompt = $this->config->theme()->replayPrompt();

        if (!empty($this->inputBuffer)) {
            $line = \array_shift($this->inputBuffer);
            if (!$line instanceof SilentInput) {
                $this->output->writeln(\sprintf('<whisper>%s</whisper><aside>%s</aside>', $prompt, OutputFormatter::escape($line)));
            }

            return $line;
        }

        $this->writeLegacyPromptSpacer();

        // Interactive readline manages bracketed paste internally
        $usesInteractiveReadline = $this->readline instanceof InteractiveReadlineInterface;
        $bracketedPaste = $interactive && $this->config->useBracketedPaste() && !$usesInteractiveReadline;

        if ($bracketedPaste) {
            \printf("\e[?2004h"); // Enable bracketed paste
        }

        $line = $this->readline->readline($this->getPrompt());

        if ($bracketedPaste) {
            \printf("\e[?2004l"); // ... and disable it again
        }

        return $line;
    }

    /**
     * Get the shell output header.
     */
    protected function getHeader(): string
    {
        return \sprintf('<whisper>%s by Justin Hileman</whisper>', self::getVersionHeader($this->config->useUnicode()));
    }

    /**
     * Get the current version of Psy Shell.
     *
     * @deprecated call self::getVersionHeader instead
     */
    public function getVersion(): string
    {
        @\trigger_error('`getVersion` is deprecated; call `self::getVersionHeader` instead.', \E_USER_DEPRECATED);

        return self::getVersionHeader($this->config->useUnicode());
    }

    /**
     * Get a pretty header including the current version of Psy Shell.
     *
     * @param bool $useUnicode
     */
    public static function getVersionHeader(bool $useUnicode = false): string
    {
        $separator = $useUnicode ? '—' : '-';

        return \sprintf('Psy Shell %s (PHP %s %s %s)', self::VERSION, \PHP_VERSION, $separator, \PHP_SAPI);
    }

    /**
     * Get a PHP manual database instance.
     *
     * @deprecated Use getManual() instead for unified access to all manual formats
     *
     * @return \PDO|null
     */
    public function getManualDb()
    {
        return $this->config->getManualDb();
    }

    /**
     * Get a PHP manual loader.
     *
     * @return Manual\ManualInterface|null
     */
    public function getManual()
    {
        return $this->config->getManual();
    }

    /**
     * Initialize tab completion matchers.
     *
     * If tab completion is enabled this adds tab completion matchers to the
     * auto completer and sets context if needed.
     */
    protected function initializeTabCompletion()
    {
        if (!$this->config->useTabCompletion() || $this->readline instanceof InteractiveReadlineInterface) {
            return;
        }

        $this->autoCompleter = $this->config->getAutoCompleter();
        if ($this->completionEngine === null) {
            throw new \LogicException('Completion engine must be initialized before tab completion.');
        }

        $this->autoCompleter->setCompletionEngine($this->completionEngine);
        $this->autoCompleter->activate();
    }

    /**
     * Initialize context-aware completion for the active readline frontend.
     */
    private function initializeCompletionEngine(): void
    {
        $completion = new CompletionEngine($this->context, $this->cleaner);
        $this->completionEngine = $completion;

        $allCommands = $this->all();
        $commandContextRefiner = new CommandContextRefiner($allCommands);
        $commandSource = new CommandSource($allCommands);
        $commandOptionSource = new CommandOptionSource($allCommands);
        $commandArgumentSource = new CommandArgumentSource($allCommands);
        $completion->addRefiner($commandContextRefiner);
        $this->commandCompletion[] = $commandContextRefiner;
        $this->commandCompletion[] = $commandSource;
        $this->commandCompletion[] = $commandOptionSource;
        $this->commandCompletion[] = $commandArgumentSource;

        $sources = [
            $commandSource,
            $commandOptionSource,
            $commandArgumentSource,
        ];

        if ($this->readline instanceof InteractiveReadlineInterface) {
            $sources[] = new HistorySource($this->readline->getHistory());
        }

        $completion->registerDefaultSources($sources);

        foreach ($this->pendingCompletionSources as $source) {
            $completion->addSource($source);
        }
        $this->pendingCompletionSources = [];

        $this->addLegacyMatchersToCompletionEngine($this->getDefaultCompletionCompatibilityMatchers());

        if (!empty($this->matchers)) {
            $this->addLegacyMatchersToCompletionEngine($this->matchers);
        }

        if ($this->readline instanceof InteractiveReadlineInterface) {
            $this->readline->setCompletionEngine($completion);
        }
    }

    /**
     * Filter out objects already present in an existing array.
     */
    protected function deduplicateObjects(array $new, array $existing): array
    {
        $seen = [];
        foreach ($existing as $item) {
            if (\is_object($item)) {
                $seen[\spl_object_id($item)] = true;
            }
        }

        return \array_values(\array_filter(
            $new,
            fn ($item) => !\is_object($item) || !isset($seen[\spl_object_id($item)])
        ));
    }

    /**
     * Add legacy matchers to completion engine via adapter.
     *
     * @param array $matchers Legacy matchers to adapt
     */
    private function addLegacyMatchersToCompletionEngine(array $matchers): void
    {
        if ($this->completionEngine === null) {
            throw new \LogicException('Completion engine is not set');
        }

        // Set context on context-aware matchers
        foreach ($matchers as $matcher) {
            if ($matcher instanceof ContextAware) {
                $matcher->setContext($this->context);
            }
        }

        // MatcherAdapterSource filters out matchers superseded by new-style sources
        $this->completionEngine->addSource(new MatcherAdapterSource($matchers));
    }

    /**
     * Matcher-only built-ins that do not yet have source-based equivalents.
     *
     * @return Matcher\AbstractMatcher[]
     */
    protected function getDefaultCompletionCompatibilityMatchers(): array
    {
        return [
            new Matcher\ClassMethodDefaultParametersMatcher(),
            new Matcher\ObjectMethodDefaultParametersMatcher(),
            new Matcher\FunctionDefaultParametersMatcher(),
        ];
    }

    /**
     * @todo Implement prompt to start update
     *
     * @return void|string
     */
    protected function writeVersionInfo()
    {
        if (\PHP_SAPI !== 'cli') {
            return;
        }

        try {
            $client = $this->config->getChecker();
            if (!$client->isLatest()) {
                $this->output->writeln(\sprintf('<whisper>New version is available at psysh.org/psysh (current: %s, latest: %s)</whisper>', self::VERSION, $client->getLatest()));
            }
        } catch (\InvalidArgumentException $e) {
            $this->output->writeln($e->getMessage());
        }
    }

    /**
     * Check for manual updates and write notification if available.
     */
    protected function writeManualUpdateInfo()
    {
        if (\PHP_SAPI !== 'cli') {
            return;
        }

        try {
            $checker = $this->config->getManualChecker();
            if ($checker && !$checker->isLatest()) {
                $this->output->writeln(\sprintf('<whisper>New PHP manual is available (latest: %s). Update with `doc --update-manual`</whisper>', $checker->getLatest()));
            }
        } catch (\Exception $e) {
            // Silently ignore manual update check failures
        }
    }

    /**
     * Write a startup message if set.
     */
    protected function writeStartupMessage()
    {
        $message = $this->config->getStartupMessage();
        if ($message !== null && $message !== '') {
            $this->output->writeln($message);
        }
    }
}