wip

src/Plugins/Tia.php

@@ -74,6 +74,14 @@ final class Tia implements AddsOutput, HandlesArguments, Terminable
 
     private const string REBUILD_OPTION = '--tia-rebuild';
 
+    /**
+     * Bypasses `BaselineSync`'s post-failure cooldown. After a failed
+     * baseline fetch, subsequent `--tia` runs skip the fetch for 24h; this
+     * flag forces an immediate retry (e.g. right after publishing a
+     * baseline from CI for the first time).
+     */
+    private const string REFETCH_OPTION = '--tia-refetch';
+
     /**
      * State keys under which TIA persists its blobs. Kept here as constants
      * (rather than scattered strings) so the storage layout is visible in
@@ -103,6 +111,14 @@ final class Tia implements AddsOutput, HandlesArguments, Terminable
      */
     public const string KEY_COVERAGE_MARKER = 'coverage.marker';
 
+    /**
+     * Cooldown marker keyed by `BaselineSync` after a failed fetch. Holds
+     * `{"until": <unix>}` — subsequent runs within the window skip the
+     * fetch attempt (and its `gh run list` network hop) until the
+     * cooldown expires or the user passes `--tia-refetch`.
+     */
+    public const string KEY_FETCH_COOLDOWN = 'fetch-cooldown.json';
+
     /**
      * Global flag toggled by the parent process so workers know to record.
      */
@@ -199,6 +215,12 @@ final class Tia implements AddsOutput, HandlesArguments, Terminable
      */
     private bool $recordingActive = false;
 
+    /**
+     * True when `--tia-refetch` is in the current argv — `BaselineSync`
+     * uses it to bypass the post-failure fetch cooldown.
+     */
+    private bool $forceRefetch = false;
+
     public function __construct(
         private readonly OutputInterface $output,
         private readonly Recorder $recorder,
@@ -310,13 +332,15 @@ final class Tia implements AddsOutput, HandlesArguments, Terminable
 
         $enabled = $this->hasArgument(self::OPTION, $arguments);
         $forceRebuild = $this->hasArgument(self::REBUILD_OPTION, $arguments);
+        $this->forceRefetch = $this->hasArgument(self::REFETCH_OPTION, $arguments);
 
-        if (! $enabled && ! $forceRebuild && ! $recordingGlobal && ! $replayingGlobal) {
+        if (! $enabled && ! $forceRebuild && ! $this->forceRefetch && ! $recordingGlobal && ! $replayingGlobal) {
             return $arguments;
         }
 
         $arguments = $this->popArgument(self::OPTION, $arguments);
         $arguments = $this->popArgument(self::REBUILD_OPTION, $arguments);
+        $arguments = $this->popArgument(self::REFETCH_OPTION, $arguments);
 
         // When `--coverage` is active, piggyback on PHPUnit's CodeCoverage
         // instead of starting our own PCOV / Xdebug session. Running two
@@ -401,6 +425,16 @@ final class Tia implements AddsOutput, HandlesArguments, Terminable
         $graph->replaceEdges($perTest);
         $graph->pruneMissingTests();
 
+        // Fold in the results collected during this same record run. The
+        // `AddsOutput` pass that runs `snapshotTestResults` fires *before*
+        // `terminate()` in the shutdown chain, so by the time the graph
+        // lands on disk, the snapshot pass has already returned empty.
+        // Writing results here means a first `--tia` invocation produces
+        // a graph with edges *and* results — the immediate next run hits
+        // cache for every unchanged test rather than needing a "warm-up"
+        // pass.
+        $this->seedResultsInto($graph);
+
         if (! $this->saveGraph($graph)) {
             $this->output->writeln('  <fg=red>TIA</> failed to write graph.');
             $recorder->reset();
@@ -635,7 +669,7 @@ final class Tia implements AddsOutput, HandlesArguments, Terminable
         // to pull a team-shared baseline so fresh checkouts (new devs, CI
         // containers) don't pay the full record cost. If the pull succeeds
         // the graph is re-read and reconciled against the local env.
-        if (! $graph instanceof Graph && ! $forceRebuild && $this->baselineSync->fetchIfAvailable($projectRoot)) {
+        if (! $graph instanceof Graph && ! $forceRebuild && $this->baselineSync->fetchIfAvailable($projectRoot, $this->forceRefetch)) {
             $graph = $this->loadGraph($projectRoot);
             if ($graph instanceof Graph) {
                 $graph = $this->reconcileFingerprint($graph, $fingerprint);
@@ -1147,6 +1181,31 @@ final class Tia implements AddsOutput, HandlesArguments, Terminable
         $this->saveGraph($graph);
     }
 
+    /**
+     * In-memory equivalent of `snapshotTestResults()` — transfers the
+     * collected results straight into the given graph instance without a
+     * load/save round-trip. Used on the record path where the graph
+     * hasn't hit disk yet and a separate `loadGraph()` would find nothing.
+     */
+    private function seedResultsInto(Graph $graph): void
+    {
+        /** @var ResultCollector $collector */
+        $collector = Container::getInstance()->get(ResultCollector::class);
+
+        foreach ($collector->all() as $testId => $result) {
+            $graph->setResult(
+                $this->branch,
+                $testId,
+                $result['status'],
+                $result['message'],
+                $result['time'],
+                $result['assertions'],
+            );
+        }
+
+        $collector->reset();
+    }
+
     /**
      * Merges per-test status + message from the `ResultCollector` into the
      * TIA graph. Runs after every `--tia` invocation so the graph always has

src/Plugins/Tia/BaselineSync.php

@@ -62,6 +62,15 @@ final readonly class BaselineSync
 
     private const string COVERAGE_ASSET = Tia::KEY_COVERAGE_CACHE;
 
+    /**
+     * Cooldown (in seconds) applied after a failed baseline fetch.
+     * Rationale: when the remote workflow hasn't published yet, every
+     * `pest --tia` invocation would otherwise re-hit `gh run list` and
+     * re-print the publish instructions — noisy + slow. Back off for a
+     * day, let the user override with `--tia-refetch`.
+     */
+    private const int FETCH_COOLDOWN_SECONDS = 86400;
+
     public function __construct(
         private State $state,
         private OutputInterface $output,
@@ -72,8 +81,12 @@ final readonly class BaselineSync
      * contents into the TIA state store. Returns true when the graph blob
      * landed; coverage is best-effort since plain `--tia` (no `--coverage`)
      * never reads it.
+     *
+     * `$force = true` (driven by `--tia-refetch`) ignores the post-failure
+     * cooldown so the user can retry on demand without waiting out the
+     * 24h window.
      */
-    public function fetchIfAvailable(string $projectRoot): bool
+    public function fetchIfAvailable(string $projectRoot, bool $force = false): bool
     {
         $repo = $this->detectGitHubRepo($projectRoot);
 
@@ -81,6 +94,16 @@ final readonly class BaselineSync
             return false;
         }
 
+        if (! $force && ($remaining = $this->cooldownRemaining()) !== null) {
+            $this->output->writeln(sprintf(
+                '  <fg=yellow>TIA</> last fetch found no baseline — next auto-retry in %s. '
+                    .'Override with <fg=cyan>--tia-refetch</>.',
+                $this->formatDuration($remaining),
+            ));
+
+            return false;
+        }
+
         $this->output->writeln(sprintf(
             '  <fg=cyan>TIA</> fetching baseline from <fg=white>%s</>…',
             $repo,
@@ -89,6 +112,7 @@ final readonly class BaselineSync
         $payload = $this->download($repo);
 
         if ($payload === null) {
+            $this->startCooldown();
             $this->emitPublishInstructions($repo);
 
             return false;
@@ -102,6 +126,11 @@ final readonly class BaselineSync
             $this->state->write(Tia::KEY_COVERAGE_CACHE, $payload['coverage']);
         }
 
+        // Successful fetch wipes any stale cooldown so the next failure
+        // (say, weeks later) starts a fresh 24h timer rather than inheriting
+        // one from the deep past.
+        $this->clearCooldown();
+
         $this->output->writeln(sprintf(
             '  <fg=green>TIA</> baseline ready (%s).',
             $this->formatSize(strlen($payload['graph']) + strlen($payload['coverage'] ?? '')),
@@ -110,6 +139,54 @@ final readonly class BaselineSync
         return true;
     }
 
+    /**
+     * Seconds left on the cooldown, or `null` when the cooldown is cleared
+     * / expired / unreadable.
+     */
+    private function cooldownRemaining(): ?int
+    {
+        $raw = $this->state->read(Tia::KEY_FETCH_COOLDOWN);
+
+        if ($raw === null) {
+            return null;
+        }
+
+        $decoded = json_decode($raw, true);
+
+        if (! is_array($decoded) || ! isset($decoded['until']) || ! is_int($decoded['until'])) {
+            return null;
+        }
+
+        $remaining = $decoded['until'] - time();
+
+        return $remaining > 0 ? $remaining : null;
+    }
+
+    private function startCooldown(): void
+    {
+        $this->state->write(Tia::KEY_FETCH_COOLDOWN, (string) json_encode([
+            'until' => time() + self::FETCH_COOLDOWN_SECONDS,
+        ]));
+    }
+
+    private function clearCooldown(): void
+    {
+        $this->state->delete(Tia::KEY_FETCH_COOLDOWN);
+    }
+
+    private function formatDuration(int $seconds): string
+    {
+        if ($seconds >= 3600) {
+            return (int) round($seconds / 3600).'h';
+        }
+
+        if ($seconds >= 60) {
+            return (int) round($seconds / 60).'m';
+        }
+
+        return $seconds.'s';
+    }
+
     /**
      * Prints actionable instructions for publishing a first baseline when
      * the consumer-side fetch finds nothing.