@vzn/vx 0.0.606 → 0.0.608

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.606",
+  "version": "0.0.608",
   "description": "The fastest task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.606",
-    "@vzn/vx-linux-arm64": "0.0.606",
-    "@vzn/vx-darwin-x64": "0.0.606",
-    "@vzn/vx-darwin-arm64": "0.0.606"
+    "@vzn/vx-linux-x64": "0.0.608",
+    "@vzn/vx-linux-arm64": "0.0.608",
+    "@vzn/vx-darwin-x64": "0.0.608",
+    "@vzn/vx-darwin-arm64": "0.0.608"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/key-fold.ts

@@ -153,6 +153,10 @@ export async function foldKey(
   h = xxh3(`pkg:${input.projectPackageJsonHash}`, h)
   h = xxh3(`config:${input.taskConfigHash}`, h)
   if (cap) {
+    // Recorded so `vx why` can name a key that moved only because vx
+    // keys differently now (an upgrade): unrecorded, every task's miss
+    // read as "inputs differ" with no input changed (X-142).
+    cap.push({ kind: 'format', name: 'cache-version', hash: CACHE_VERSION })
     cap.push({ kind: 'workspace', name: 'fingerprint', hash: input.workspaceFingerprint })
     cap.push({ kind: 'package', name: 'package.json', hash: input.projectPackageJsonHash })
     cap.push({ kind: 'config', name: 'config', hash: input.taskConfigHash })

package/src/cli/run.ts

@@ -11,7 +11,6 @@ import {
   run as runOrchestrator,
   shellQuote,
   type RunOptions,
-  type RunResult,
 } from '../orchestrator/index.js'
 import type { ContinueMode, TaskOutcome } from '../graph/index.js'
 import {
@@ -721,6 +720,12 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       return 1
     }
     if (plan.tasks.length === 0) {
+      // The run's own line: a dry run that guessed from the scope alone
+      // said no affected project declared a task one did (X-141).
+      if (plan.noneAffected !== undefined) {
+        process.stderr.write(`${plan.noneAffected}\n`)
+        return 0
+      }
       if (opts.selectedByDiff === true) {
         process.stderr.write(`vx run: no affected project declares task(s): ${tasks.join(', ')}.\n`)
         return 0

package/src/cli/why.ts

@@ -49,6 +49,8 @@ export const WHAT_TO_DO: Readonly<Record<string, string>> = {
     "the task's evaluated config changed (its vx.config or a file it imports); `vx show <that task>` prints it as it is now",
   upstream: "a dependency's key moved; `vx why <that task>` says why",
   plugin: "a key plugin's material changed; that plugin decides what it folds",
+  format:
+    'vx keys tasks differently since an upgrade; every cached task misses once, nothing to fix',
 }
 
 export function parseWhyArgs(args: readonly string[]): WhyArgs {

package/src/orchestrator/plan.ts

@@ -82,6 +82,8 @@ export interface RunPlan {
   unresolvedTasks?: readonly string[]
   /** What `vx run` appends to that refusal: the nearest declared names, or how to declare one. */
   unresolvedHint?: string
+  /** Set when `--affected` left nothing to run: the line the run would print, and why. */
+  noneAffected?: string
   /**
    * Producers `--download` WANTED to defer but could not, mapped to why.
    * Without this the gate is invisible: a user asks for `--download=none`,

package/src/orchestrator/run.ts

@@ -404,20 +404,7 @@ async function runOnBus(
     return { ok: false, outcomes: [], refused }
   }
   if (prepared.empty === 'none-affected') {
-    // A changed project declares the task, so `--affected`'s task walk is
-    // what left nothing (affected-tasks.ts), not the scope.
-    const inScope = new Set(options.projects ?? [])
-    const reachedNone =
-      options.affected !== undefined &&
-      [...prepared.projects.values()].some(
-        (p) =>
-          inScope.has(p.name) && options.tasks.some((t) => declaredTask(p.config, t) !== undefined),
-      )
-    log.status(
-      reachedNone
-        ? `Nothing affected: the change reaches no ${options.tasks.join(', ')} task.`
-        : `No affected project declares task(s): ${options.tasks.join(', ')}.`,
-    )
+    log.status(noneAffected(prepared, options))
     await teardown()
     prepared.cache.close()
     return { ok: true, outcomes: [] }
@@ -1516,6 +1503,22 @@ async function applyCacheRetention(prepared: PreparedRun): Promise<void> {
   }
 }
 
+/** Why an `--affected` run has nothing to run, said alike by the run and its `--dry` plan. */
+function noneAffected(prepared: PreparedRun, options: RunOptions): string {
+  // A changed project declares the task, so `--affected`'s task walk is
+  // what left nothing (affected-tasks.ts), not the scope.
+  const inScope = new Set(options.projects ?? [])
+  const reachedNone =
+    options.affected !== undefined &&
+    [...prepared.projects.values()].some(
+      (p) =>
+        inScope.has(p.name) && options.tasks.some((t) => declaredTask(p.config, t) !== undefined),
+    )
+  return reachedNone
+    ? `Nothing affected: the change reaches no ${options.tasks.join(', ')} task.`
+    : `No affected project declares task(s): ${options.tasks.join(', ')}.`
+}
+
 /**
  * Planning mode. Same setup as `run()` — workspace discovery, config
  * load, package graph, task graph — but stops short of execution.
@@ -1548,6 +1551,8 @@ export async function planRun(options: RunOptions): Promise<RunPlan> {
         unresolvedHint: elsewhereHint(prepared.declaredElsewhere),
       }
     }
+    if (prepared.empty === 'none-affected')
+      return { tasks: [], noneAffected: noneAffected(prepared, options) }
     if (prepared.empty !== null) return { tasks: [] }
     // Its own mark: a dry run's plan (every task's hash, the cache lookups,
     // the history p50s) was booked under `close`, the next mark, and read