Rebuild process execution safely

README.md

@@ -37,24 +37,6 @@ Behind the scenes, cpx will install the package into a separate directory and ru
 
 ---
 
-As different projects may use different tools to do the same job, cpx provides a set of commands to normalise common tasks, using the packages a project has installed; `cpx check`, `cpx format` and `cpx test`.
-
-For each of these commands, you can continue to pass through additional arguments and flags to the underlying tool as if you were running it directly.
-
-### cpx check
-
-`cpx check` (or the aliases `cpx analyze` or `cpx analyse`) runs a static analysis tool on your codebase (e.g. PHPStan, Psalm or Phan).
-
-### cpx format
-
-`cpx format` (or the alias `cpx fmt`) Runs a code formatting tool on your codebase (e.g. PHP-CS-Fixer, Pint or PHP_CodeSniffer).
-
-You can pass the `--dry-run` flag to see what changes would be made without actually making them.
-
-### cpx test
-
-`cpx test` runs a testing framework on your codebase (e.g. Pest, PHPUnit or Codeception).
-
 ### cpx aliases
 
 `cpx aliases` will show a list of popular packages that have been aliased to make them easier to run. You can use these aliases to run a package without needing to remember the full vendor, package and command name.
@@ -94,7 +76,7 @@ When using these commands, you get the following benefits:
 
 ### cpx help
 
-`cpx help` will show a list of all the commands available in cpx.
+`cpx help` shows usage information, and `cpx help <command>` shows help for a specific command.
 
 ## FAQ:
 

composer.json

@@ -34,7 +34,8 @@
         }
     },
     "require": {
-        "php": "^8.3"
+        "php": "^8.3",
+        "symfony/console": "^7.4|^8.0"
     },
     "require-dev": {
         "laravel/pao": "^1.1",

cpx

@@ -1,22 +1,7 @@
 #! /usr/bin/env php
 <?php
 
-use Cpx\Console;
-use Cpx\Package;
-use Cpx\PackageAliases;
-use Cpx\Commands\Command;
-use Cpx\Commands\ExecCommand;
-use Cpx\Commands\HelpCommand;
-use Cpx\Commands\ListCommand;
-use Cpx\Commands\TestCommand;
-use Cpx\Commands\CheckCommand;
-use Cpx\Commands\CleanCommand;
-use Cpx\Commands\FormatCommand;
-use Cpx\Commands\TinkerCommand;
-use Cpx\Commands\UpdateCommand;
-use Cpx\Commands\AliasesCommand;
-use Cpx\Commands\UpgradeCommand;
-use Cpx\Commands\VersionCommand;
+use Cpx\Application;
 
 if (isset($GLOBALS['_composer_autoload_path'])) {
     require_once $GLOBALS['_composer_autoload_path'];
@@ -34,37 +19,4 @@ if (isset($GLOBALS['_composer_autoload_path'])) {
     unset($file);
 }
 
-array_shift($argv);
-$console = Console::parse($argv ?? []);
-
-$command = match (true) {
-    $console->command === 'list' => ListCommand::class,
-    $console->command === 'help' => HelpCommand::class,
-    $console->command === 'clean' => CleanCommand::class,
-    $console->command === 'aliases' => AliasesCommand::class,
-    $console->command === 'update' => UpdateCommand::class,
-    $console->command === 'upgrade' => UpgradeCommand::class,
-    $console->command === 'exec' => ExecCommand::class,
-    $console->command === 'format' || $console->command === 'fmt' => FormatCommand::class,
-    $console->command === 'check' || $console->command === 'analyze' || $console->command === 'analyse' => CheckCommand::class,
-    $console->command === 'test' => TestCommand::class,
-    $console->command === 'tinker' => TinkerCommand::class,
-    $console->command === 'version' => VersionCommand::class,
-    file_exists(realpath($console->command)) && !is_dir(realpath($console->command)) => (new ExecCommand(Console::parse("exec {$console->command} {$console->getCommandInput()}")))(),
-    array_key_exists($console->command, PackageAliases::$packages) => Package::parse(PackageAliases::$packages[$console->command]['package'])->runCommand($console),
-    str_contains($console->command, '/') => Package::parse($console->command)->runCommand($console),
-    $console->command === '--version' || $console->command === '-v' || $console->hasOption('version') || $console->hasOption('v') => VersionCommand::class,
-    default => (new HelpCommand($console))(true),
-};
-
-try {
-    if (is_subclass_of($command, Command::class)) {
-        $command = new $command($console);
-        $command();
-    } elseif (is_callable($command)) {
-        $command();
-    }
-} catch (Exception $e) {
-    echo Command::BACKGROUND_RED . "  {$e->getMessage()}  " . Command::COLOR_RESET . PHP_EOL;
-    exit(1);
-}
+exit((new Application)->run());

files/psysh-config.php

@@ -1,6 +1,6 @@
 <?php
 
-use Cpx\PhpExecutionHelper;
+use Cpx\Runtime\PhpExecutionHelper;
 
 require_once __DIR__.'/../vendor/autoload.php';
 

pint.json

@@ -15,6 +15,25 @@
         "global_namespace_import": {
             "import_classes": true
         },
+        "ordered_class_elements": {
+            "order": [
+                "use_trait",
+                "case",
+                "constant_public",
+                "constant_protected",
+                "constant_private",
+                "property_public",
+                "property_protected",
+                "property_private",
+                "construct",
+                "destruct",
+                "magic",
+                "method_public",
+                "method_protected",
+                "method_private"
+            ],
+            "sort_algorithm": "none"
+        },
         "trailing_comma_in_multiline": {
             "elements": [
                 "arguments",

src/Application.php

@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cpx;
+
+use Cpx\Commands\AliasesCommand;
+use Cpx\Commands\CleanCommand;
+use Cpx\Commands\ExecCommand;
+use Cpx\Commands\ListCommand;
+use Cpx\Commands\RunPackageCommand;
+use Cpx\Commands\TinkerCommand;
+use Cpx\Commands\UpdateCommand;
+use Cpx\Commands\UpgradeCommand;
+use Cpx\Packages\PackageCommandRunner;
+use Symfony\Component\Console\Application as SymfonyApplication;
+use Symfony\Component\Console\Input\ArgvInput;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class Application extends SymfonyApplication
+{
+    public function __construct(?PackageCommandRunner $packageCommandRunner = null)
+    {
+        parent::__construct('cpx', $this->resolveVersion());
+        $this->setAutoExit(false);
+
+        $this->registerCommands($packageCommandRunner ?? new PackageCommandRunner);
+    }
+
+    public function run(?InputInterface $input = null, ?OutputInterface $output = null): int
+    {
+        $input ??= new ArgvInput;
+
+        if ($input instanceof ArgvInput && $this->shouldRunPackageFallback($input)) {
+            $input = new ArgvInput(['cpx', RunPackageCommand::NAME, '--', ...$input->getRawTokens()]);
+        }
+
+        return parent::run($input, $output);
+    }
+
+    protected function getCommandName(InputInterface $input): ?string
+    {
+        $command = parent::getCommandName($input);
+
+        return $command === null || $this->has($command)
+            ? $command
+            : RunPackageCommand::NAME;
+    }
+
+    private function registerCommands(PackageCommandRunner $packageCommandRunner): void
+    {
+        $this->addCommands([
+            new ListCommand,
+            new AliasesCommand,
+            new CleanCommand,
+            new UpdateCommand,
+            new UpgradeCommand,
+            new ExecCommand,
+            new TinkerCommand,
+            new RunPackageCommand($packageCommandRunner),
+        ]);
+    }
+
+    private function resolveVersion(): string
+    {
+        $contents = file_get_contents(__DIR__.'/../composer.json');
+
+        if ($contents === false) {
+            return 'unknown';
+        }
+
+        $decoded = json_decode($contents, true);
+
+        return is_array($decoded) && is_string($decoded['version'] ?? null)
+            ? $decoded['version']
+            : 'unknown';
+    }
+
+    private function shouldRunPackageFallback(ArgvInput $input): bool
+    {
+        $command = $input->getRawTokens()[0] ?? null;
+
+        return is_string($command)
+            && ! in_array($command, ['--version', '-v'], true)
+            && ! $this->has($command);
+    }
+}

src/Cache/Metadata.php

@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cpx\Cache;
+
+use Cpx\Packages\Package;
+use Cpx\Support\Arr;
+
+class Metadata
+{
+    private const FILE = '.cpx_metadata.json';
+
+    /**
+     * @param  array<string, PackageMetadata>  $packages
+     * @param  array<string, array{packages?: list<string>, last_updated?: int, last_run?: int}>  $execCache
+     */
+    protected function __construct(
+        public array $packages = [],
+        public array $execCache = [],
+    ) {}
+
+    public static function open(): self
+    {
+        $metadataFile = cpx_path(self::FILE);
+
+        if (! file_exists($metadataFile)) {
+            return new self;
+        }
+
+        $contents = file_get_contents($metadataFile);
+        $json = $contents === false ? [] : json_decode($contents, true);
+
+        if (! is_array($json)) {
+            $json = [];
+        }
+
+        return new self(
+            packages: Arr::mapWithKeys(
+                fn (string $key, array $value): array => [
+                    $key => new PackageMetadata(
+                        package: Package::parse($key),
+                        lastUpdatedAt: $value['last_updated'] ?? null,
+                        lastRunAt: $value['last_run'] ?? null,
+                    ),
+                ],
+                is_array($json['packages'] ?? null) ? $json['packages'] : [],
+            ),
+            execCache: is_array($json['execCache'] ?? null) ? $json['execCache'] : [],
+        );
+    }
+
+    public function recordRun(Package $package): self
+    {
+        $this->forPackage($package)->lastRunAt = date('Y-m-d H:i:s');
+
+        return $this;
+    }
+
+    public function recordUpdate(Package $package): self
+    {
+        $this->forPackage($package)->lastUpdatedAt = date('Y-m-d H:i:s');
+
+        return $this;
+    }
+
+    public function save(): void
+    {
+        $metadataFile = cpx_path(self::FILE);
+
+        if (! is_dir(dirname($metadataFile))) {
+            mkdir(dirname($metadataFile), 0755, true);
+        }
+
+        file_put_contents($metadataFile, json_encode($this->toArray(), JSON_PRETTY_PRINT));
+    }
+
+    public function hasPackage(string|Package $package): bool
+    {
+        if ($package instanceof Package) {
+            $package = $package->fullPackageString();
+        }
+
+        return array_key_exists($package, $this->packages);
+    }
+
+    /**
+     * @return array{
+     *     packages: array<string, array{last_updated: string|null, last_run: string|null}>,
+     *     execCache: array<string, array{packages?: list<string>, last_updated?: int, last_run?: int}>
+     * }
+     */
+    public function toArray(): array
+    {
+        return [
+            'packages' => Arr::mapWithKeys(
+                fn (string $key, PackageMetadata $packageMetadata): array => [
+                    $packageMetadata->package->fullPackageString() => [
+                        'last_updated' => $packageMetadata->lastUpdatedAt,
+                        'last_run' => $packageMetadata->lastRunAt,
+                    ],
+                ],
+                $this->packages,
+            ),
+            'execCache' => $this->execCache,
+        ];
+    }
+
+    private function forPackage(Package $package): PackageMetadata
+    {
+        return $this->packages[$package->fullPackageString()] ??= new PackageMetadata($package);
+    }
+}

src/PackageMetadata.php → src/Cache/PackageMetadata.php

@@ -2,12 +2,14 @@
 
 declare(strict_types=1);
 
-namespace Cpx;
+namespace Cpx\Cache;
+
+use Cpx\Packages\Package;
 
 class PackageMetadata
 {
     public function __construct(
-        public Package $package,
+        public readonly Package $package,
         public ?string $lastUpdatedAt = null,
         public ?string $lastRunAt = null,
     ) {}