@vzn/vx 0.0.652 → 0.0.653

package/src/cli/run.ts

@@ -9,7 +9,7 @@ import {
   shellQuote,
   type RunOptions,
 } from '../orchestrator/index.js'
-import type { ContinueMode } from '../graph/index.js'
+import { type ContinueMode, isKeyFailed } from '../graph/index.js'
 import {
   applyCacheFlags,
   type CacheFlags,
@@ -18,7 +18,13 @@ import {
   gitRefusal,
   parseCachePolicy,
 } from '../cache/index.js'
-import { affectedFilterFor, findCwdSelection, pickTask, resolveFilters } from './select.js'
+import {
+  type AffectedFilter,
+  affectedFilterFor,
+  findCwdSelection,
+  pickTask,
+  resolveFilters,
+} from './select.js'
 import { nxTargetHint, taskNamesHere, undeclaredTasks } from './task-verb.js'
 import { envFlagOn, hasControl, parseDecimalInt } from '../util/index.js'
 import * as ui from '../ui/index.js'
@@ -408,7 +414,7 @@ async function scopeFilters(
   parsed: RunArgs,
   cwd: string,
 ): Promise<
-  { filterStrings: string[]; affectedFilter?: string } | { error: string; code?: string }
+  { filterStrings: string[]; affected?: AffectedFilter } | { error: string; code?: string }
 > {
   // `--affected[=<base>]` is sugar for `--filter '...[<base>]'`: the
   // changed projects AND their dependents — what a CI gate must run, what
@@ -421,14 +427,21 @@ async function scopeFilters(
   // drops app from either side (item 955 had put it first for that). First
   // it stays, so a message naming the filters names it first.
   const filterStrings = [...parsed.filters]
-  let affectedFilter: string | undefined
+  let affected: AffectedFilter | undefined
   if (parsed.affected !== undefined) {
-    const f = await affectedFilterFor(cwd, parsed.affected)
-    if (typeof f === 'object') return f
-    affectedFilter = f
-    filterStrings.unshift(affectedFilter)
+    // With --all given, "run --all" is advice already taken.
+    const f = await affectedFilterFor(
+      cwd,
+      parsed.affected,
+      parsed.all
+        ? 'drop --affected, --all runs every project (the cache skips what did not change)'
+        : undefined,
+    )
+    if ('error' in f) return f
+    affected = f
+    filterStrings.unshift(f.filter)
   }
-  return { filterStrings, ...(affectedFilter !== undefined ? { affectedFilter } : {}) }
+  return { filterStrings, ...(affected !== undefined ? { affected } : {}) }
 }
 
 /**
@@ -477,10 +490,10 @@ export async function resolveRunOptions(
 
   const scope = await scopeFilters(parsed, cwd)
   if ('error' in scope) return scope
-  const { filterStrings, affectedFilter } = scope
+  const { filterStrings, affected: affectedFilter } = scope
   // `...[<base>]`: the base alone.
   if (scopeOut !== undefined && affectedFilter !== undefined)
-    scopeOut.affectedBase = affectedFilter.slice(4, -1)
+    scopeOut.affectedBase = affectedFilter.filter.slice(4, -1)
 
   // Project scope applies to bare task names only. Anchored entries
   // (pkg#task) resolve directly to their own project regardless.
@@ -611,17 +624,47 @@ export async function runCmd(args: readonly string[]): Promise<number> {
   // anchored pkg#task; the rest of the pipeline treats it like any
   // explicit anchored positional.
   if (tasks.length === 0) {
+    const load = parsed.cacheDir !== undefined ? { cacheDir: parsed.cacheDir } : {}
+    // `--filter` / `--affected` scope the menu and the list, as they scope a
+    // bare task: the menu listed every project and the anchored pick ran
+    // outside it; the list named the cwd's tasks.
+    const selection = async (): Promise<
+      { only?: ReadonlySet<string> } | { error: string; code?: string } | { empty: string }
+    > => {
+      const scope = await scopeFilters(parsed, cwd)
+      if ('error' in scope) return scope
+      if (scope.filterStrings.length === 0) return {}
+      const selected = await resolveFilters(cwd, scope.filterStrings, load, scope.affected)
+      if ('error' in selected || 'empty' in selected) return selected
+      return { only: new Set(selected.names) }
+    }
     // A JSON answer is for a program, which cannot pick from a menu: an
     // agent on a pty waited at the picker forever.
     const forProgram = parsed.dry === 'json'
     if (!process.stdin.isTTY || forProgram) {
-      const names = await taskNamesHere(cwd)
-      const shown = (names ?? []).slice(0, TASKS_SHOWN)
-      const more = (names?.length ?? 0) - shown.length
+      const scoped = await selection()
+      if ('error' in scoped) return refuse('run', args, scoped.error, scoped.code ?? 'VX_E_USAGE')
+      const asked =
+        'empty' in scoped ? undefined : (scoped.only ?? (parsed.all ? 'all' : undefined))
+      const here = 'empty' in scoped ? null : await taskNamesHere(cwd, asked)
+      const names = here?.names ?? []
+      const shown = names.slice(0, TASKS_SHOWN)
+      const more = names.length - shown.length
+      const list = `${shown.join(', ')}${more > 0 ? ` and ${more} more` : ''}`
+      // Outside a project a bare name is refused without --all: the list
+      // said "tasks here", and `vx run build` then said "not inside a project".
       const tasksHere =
-        shown.length === 0
-          ? 'vx run <task>, e.g. vx run build'
-          : `tasks here: ${shown.join(', ')}${more > 0 ? ` and ${more} more` : ''}`
+        'empty' in scoped
+          ? scoped.empty
+          : shown.length === 0
+            ? 'vx run <task>, e.g. vx run build'
+            : asked === 'all'
+              ? `every project's tasks: ${list}`
+              : asked !== undefined
+                ? `the selected projects' tasks: ${list}`
+                : here?.inProject === false
+                  ? `not inside a project, the workspace's tasks with --all: ${list}`
+                  : `tasks here: ${list}`
       return refuse(
         'run',
         args,
@@ -635,23 +678,13 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       sayLine('error', refusal.message, 'vx run')
       return 1
     }
-    const load = parsed.cacheDir !== undefined ? { cacheDir: parsed.cacheDir } : {}
-    // `--filter` / `--affected` scope the menu, as they scope a bare task:
-    // the menu listed every project and the anchored pick ran outside it.
-    const scope = await scopeFilters(parsed, cwd)
-    if ('error' in scope) return refuse('run', args, scope.error, scope.code ?? 'VX_E_USAGE')
-    let only: ReadonlySet<string> | undefined
-    if (scope.filterStrings.length > 0) {
-      const selected = await resolveFilters(cwd, scope.filterStrings, load, scope.affectedFilter)
-      if ('error' in selected)
-        return refuse('run', args, selected.error, selected.code ?? 'VX_E_USAGE')
-      if ('empty' in selected) {
-        sayNotice('info', 'vx run', selected.empty)
-        return 0
-      }
-      only = new Set(selected.names)
+    const scoped = await selection()
+    if ('error' in scoped) return refuse('run', args, scoped.error, scoped.code ?? 'VX_E_USAGE')
+    if ('empty' in scoped) {
+      sayNotice('info', 'vx run', scoped.empty)
+      return 0
     }
-    const chosen = await pickTask(cwd, {}, load, only)
+    const chosen = await pickTask(cwd, {}, load, scoped.only)
     if (chosen === 'interrupted') return 130
     if (!chosen) return 1
     picked = `${chosen.project}#${chosen.task}`
@@ -713,7 +746,8 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     } else {
       ui.print('out', planReport(plan))
     }
-    return 0
+    // The run fails a task whose key cannot be derived; its plan does too.
+    return isKeyFailed(plan) ? 1 : 0
   }
 
   // A run executes in THIS process, always. Where an individual task's

package/src/cli/select.ts

@@ -25,10 +25,10 @@ import {
   type ProjectMeta,
   readLockfile,
 } from '../workspace/index.js'
-import type { ProjectConfig } from '../config.js'
+import type { ProjectConfig, TaskConfig } from '../config.js'
 import type { ProjectEntry } from '../workspace/index.js'
 import { isDefaultBuild, parseDependencySpec } from '../graph/index.js'
-import { declaresInput, workspaceFilesReachInto } from '../cache/index.js'
+import { declaresInput, lazyGitEnumeration, workspaceFilesReachInto } from '../cache/index.js'
 import {
   isUserError,
   listed,
@@ -45,7 +45,6 @@ import {
   claimedExtraFiles,
   claimedDigests,
   fingerprintClaims,
-  gitOfDiscovery,
   hasHook,
   keepDiscoveryGraph,
 } from '../orchestrator/index.js'
@@ -77,17 +76,53 @@ export async function workspaceGlobOwners(
   nested: readonly string[] = [],
   /** `AffectedChanges.dirLinks`. */
   dirLinks: ReadonlySet<string> = new Set(),
+  /** `AffectedChanges.untracked`. */
+  untracked: ReadonlySet<string> = new Set(),
 ): Promise<string[]> {
-  const declaresMatch = (config: ProjectConfig): boolean => {
+  // The changed paths a `workspaceFiles` list matches, asked once per
+  // distinct list rather than once per task: tasks × changed paths was
+  // 14.5 s on 8000 projects with 64k changed paths. A tracked match selects
+  // any task declaring the list; an untracked one only a task whose own
+  // outputs it is not, so those are kept for the per-task check.
+  const byList = new Map<string, { tracked: boolean; loose: string[] }>()
+  const matchesOf = (ws: readonly string[]) => {
+    const key = ws.join('\0')
+    let found = byList.get(key)
+    if (found !== undefined) return found
+    found = { tracked: false, loose: [] }
+    const probe = { inputs: { files: [], workspaceFiles: ws } } as unknown as TaskConfig
+    for (const rel of changed) {
+      const loose = untracked.has(rel)
+      if (!declaresInput(probe, null, rel, dirLinks.has(rel))) continue
+      if (!loose) {
+        found.tracked = true
+        break
+      }
+      found.loose.push(rel)
+    }
+    byList.set(key, found)
+    return found
+  }
+  const declaresMatch = (config: ProjectConfig, projectAbs: string): boolean => {
+    let projectDir: string | undefined
     for (const task of Object.values(config.tasks ?? {})) {
-      if (changed.some((rel) => declaresInput(task, null, rel, dirLinks.has(rel)))) return true
+      const ws = task.inputs?.workspaceFiles
+      if (ws === undefined || ws.length === 0) continue
+      const input = (rel: string): boolean => {
+        const loose = untracked.has(rel)
+        if (loose) projectDir ??= relPosix(root, projectAbs)
+        return declaresInput(task, null, rel, dirLinks.has(rel), loose, projectDir)
+      }
+      // A hand-edited lock entry that is no list is asked path by path.
+      const found = Array.isArray(ws) ? matchesOf(ws) : { tracked: changed.some(input), loose: [] }
+      if (found.tracked || found.loose.some(input)) return true
       if (nested.some((dir) => workspaceFilesReachInto(task, dir))) return true
     }
     return false
   }
   try {
     const staged = await stagedLoad()
-    return [...staged.values()].filter((p) => declaresMatch(p.config)).map((p) => p.name)
+    return [...staged.values()].filter((p) => declaresMatch(p.config, p.dir)).map((p) => p.name)
   } catch {
     // Fall through to the per-file sweep.
   }
@@ -102,7 +137,7 @@ export async function workspaceGlobOwners(
     const dir = lockKey(root, meta.dir)
     if (!Object.hasOwn(lock.projects, dir)) continue
     try {
-      if (declaresMatch(lock.projects[dir]!.config)) owners.push(meta.name)
+      if (declaresMatch(lock.projects[dir]!.config, meta.dir)) owners.push(meta.name)
     } catch {
       // A hand-edited entry that will not read cannot be shown to declare a
       // matching glob; surfacing it here would fail a run the load tolerates.
@@ -287,6 +322,12 @@ function refusalOf(err: unknown): Refusal {
     : { error: err.message }
 }
 
+/** The filter `--affected` became; `env` is the `VX_AFFECTED_BASE` value that gave its base. */
+export interface AffectedFilter {
+  readonly filter: string
+  readonly env?: string
+}
+
 /**
  * The filter `--affected[=<base>]` stands for: `...[<base>]`, the changed
  * projects and their dependents. An empty base is `VX_AFFECTED_BASE`'s,
@@ -298,9 +339,10 @@ export async function affectedFilterFor(
   affected: string,
   /** What the verb does instead on the base branch (`defaultAffectedBase`). */
   instead?: string,
-): Promise<string | Refusal> {
+): Promise<AffectedFilter | Refusal> {
   const root = await findWorkspaceRoot(cwd)
-  let base = affected || ((settingEnv('affectedBase') as string | undefined) ?? '')
+  const env = affected === '' ? (settingEnv('affectedBase') as string | undefined) : undefined
+  let base = affected || (env ?? '')
   if (base === '') {
     const ws = await loadCliWorkspace(root)
     try {
@@ -312,42 +354,98 @@ export async function affectedFilterFor(
       return refusalOf(err)
     }
   }
-  return `...[${base}]`
+  return env === undefined ? { filter: `...[${base}]` } : { filter: `...[${base}]`, env }
 }
 
 export async function resolveFilters(
   cwd: string,
   raw: string[],
   load: CliLoadOptions = {},
-  /** The raw filter `--affected` became: its diff is kept per path for the run. */
-  affected?: string,
+  /** The filter `--affected` became: its diff is kept per path for the run. */
+  affected?: AffectedFilter,
   /** The verb a warning names: `vx show` and `vx watch` select as a run does. */
   verb: 'run' | 'show' | 'watch' = 'run',
 ): Promise<FilterResolution> {
   const root = await findWorkspaceRoot(cwd)
-  const projects = await loadWorkspaceProjects(cwd, load)
   let parsed: ReturnType<typeof parseFilter>[]
   try {
     parsed = raw.map((r) => parseFilter(r, root))
   } catch (err) {
+    await loadWorkspaceProjects(cwd, load)
     return refusalOf(err)
   }
+  // A filter that diffs against git reads its untracked files from the
+  // run's whole-tree walk (one walk where it spawned its own), and the run
+  // reuses it with the discovery (I-26). The walk needs only the root, so
+  // it starts before the workspace config and discovery, not after them.
+  const git = parsed.some((f) => f.gitSince !== undefined) ? lazyGitEnumeration(root) : undefined
+  void git?.start()
+  const discovering = discoverCliProjects(root, load, git)
+  discovering.catch(() => {})
   // `sinceViaDeps` (`e2e...[main]`) walks the changed projects' dependents.
   const walksGraph = parsed.some(
     (f) => f.withDeps || f.withDependents || f.onlyDeps || f.sinceViaDeps === true,
   )
-  // A filter that diffs against git starts the run's whole-tree walk now:
-  // the diff reads its untracked files from it (one walk where it spawned
-  // its own), and the run reuses it with the discovery (I-26).
-  const git = parsed.some((f) => f.gitSince !== undefined) ? gitOfDiscovery(projects) : undefined
-  void git?.start()
   // Every reader of the staged configs in this pass — the `pkg#task`
   // edge walk, the `workspaceFiles` owners of a changed path — shares
   // ONE load, and the run reuses it (`RunOptions.staged`): the `project`
   // stage runs once per project per run.
   let stagedPromise: Promise<Map<string, ProjectEntry>> | undefined
   const stagedOnce = (): Promise<Map<string, ProjectEntry>> =>
-    (stagedPromise ??= loadCliProjects(root, projects, 'all', load))
+    (stagedPromise ??= discovering.then((projects) => loadCliProjects(root, projects, 'all', load)))
+  // A scoped enumeration lists only its projects: null asks git.
+  const enumeration = async () => (git === undefined ? undefined : await git.start())
+  // Each `[<since>]` diff starts now, before discovery ends: merge-base and
+  // diff need only the root and the ref, so they overlap the workspace
+  // config, discovery and the config load, where they waited on all three.
+  // One after another, as a shallow clone's fetches must be; each is
+  // awaited in filter order below, so a refusal comes where it came.
+  const diffs = new Map<(typeof parsed)[number], Promise<AffectedChanges | Set<string>>>()
+  let previous: Promise<unknown> | undefined
+  for (const f of parsed) {
+    if (f.gitSince === undefined) continue
+    const args: Parameters<typeof affectedChanges>[0] = {
+      workspaceRoot: root,
+      since: f.gitSince,
+      projects: discovering,
+      workspaceGlobOwners: async (
+        changed: readonly string[],
+        nested: readonly string[],
+        dirLinks: ReadonlySet<string>,
+        untracked: ReadonlySet<string>,
+      ) =>
+        workspaceGlobOwners(
+          root,
+          await discovering,
+          changed,
+          load,
+          stagedOnce,
+          nested,
+          dirLinks,
+          untracked,
+        ),
+      fingerprintClaims: async () => workspaceFingerprintClaims(root, await discovering, load),
+      untracked: async () => (await enumeration())?.untracked ?? null,
+      links: async () => {
+        const g = await enumeration()
+        if (g === undefined || !g.scopes.includes('.')) return null
+        const out: string[] = []
+        for (const [rel, oid] of g.trusted) if (oid.startsWith('120000:')) out.push(rel)
+        return out
+      },
+      flagged: async () => {
+        const g = await enumeration()
+        return g !== undefined && g.scopes.includes('.') ? g.flagged : null
+      },
+    }
+    const diff = (): Promise<AffectedChanges | Set<string>> =>
+      f.raw === affected?.filter ? affectedChanges(args) : affectedProjects(args)
+    const started = previous === undefined ? diff() : previous.then(diff)
+    started.catch(() => {})
+    diffs.set(f, started)
+    previous = started
+  }
+  const projects = await discovering
   let edges: Map<string, string[]> | undefined
   if (walksGraph) {
     try {
@@ -367,50 +465,34 @@ export async function resolveFilters(
     }
   }
   const graph = buildPackageGraph(projects, edges)
-  // The graph a run reusing this discovery builds is this one when no task
-  // edge went into it.
-  if (edges === undefined) keepDiscoveryGraph(projects, graph)
+  // The graph a run reusing this discovery builds is this one when the task
+  // edges added none: each is a discovered edge already, or names no project.
+  const known = new Set(projects.map((p) => p.name))
+  if (
+    edges === undefined ||
+    projects.every((p) =>
+      (edges.get(p.name) ?? []).every((t) => !known.has(t) || p.deps?.includes(t) === true),
+    )
+  )
+    keepDiscoveryGraph(projects, graph)
 
-  // Resolve every `[<since>]` filter against git before the pure
-  // applyFilters pass runs. One spawn per distinct ref — usually
-  // there's only one anyway.
+  // Every `[<since>]` filter's diff, started above, is in before the pure
+  // applyFilters pass runs.
   const affectedByFilter = new Map<(typeof parsed)[number], Set<string>>()
+  // The diffs that named a change, though maybe in no project: a root file
+  // no task declares. Then the tree is not clean against HEAD.
+  const changedAny = new Set<(typeof parsed)[number]>()
   let changes: AffectedChanges | undefined
-  for (const f of parsed) {
-    if (f.gitSince === undefined) continue
+  for (const [f, diff] of diffs) {
     try {
-      const args = {
-        workspaceRoot: root,
-        since: f.gitSince,
-        projects,
-        workspaceGlobOwners: (
-          changed: readonly string[],
-          nested: readonly string[],
-          dirLinks: ReadonlySet<string>,
-        ) => workspaceGlobOwners(root, projects, changed, load, stagedOnce, nested, dirLinks),
-        fingerprintClaims: () => workspaceFingerprintClaims(root, projects, load),
-        ...(git !== undefined
-          ? {
-              untracked: async () => (await git.start()).untracked,
-              // A scoped enumeration lists only its projects: null asks git.
-              links: async () => {
-                const g = await git.start()
-                if (!g.scopes.includes('.')) return null
-                const out: string[] = []
-                for (const [rel, oid] of g.trusted) if (oid.startsWith('120000:')) out.push(rel)
-                return out
-              },
-              flagged: async () => {
-                const g = await git.start()
-                return g.scopes.includes('.') ? g.flagged : null
-              },
-            }
-          : {}),
-      }
+      const answer = await diff
       let names: Set<string>
-      if (f.raw === affected) {
-        changes = await affectedChanges(args)
+      if (answer instanceof Set) {
+        names = answer
+      } else {
+        changes = answer
         names = changes.projects
+        if (changes.changed.length > 0 || changes.nested !== undefined) changedAny.add(f)
         // A `graph` plugin may tie any task to a changed path (an edge, an
         // input), and the run alone builds that graph: every project is a
         // candidate, and the run keeps the tasks its final graph reaches.
@@ -420,12 +502,18 @@ export async function resolveFilters(
         ) {
           names = new Set(projects.map((p) => p.name))
         }
-      } else {
-        names = await affectedProjects(args)
       }
       affectedByFilter.set(f, names)
     } catch (err) {
-      return refusalOf(err)
+      const refusal = refusalOf(err)
+      // A base the variable gave was reported as if typed.
+      if (
+        affected?.env !== undefined &&
+        f.raw === affected.filter &&
+        refusal.code === 'VX_E_AFFECTED_BASE'
+      )
+        return { ...refusal, error: `VX_AFFECTED_BASE=${affected.env}: ${refusal.error}` }
+      return refusal
     }
   }
 
@@ -482,10 +570,14 @@ export async function resolveFilters(
         // the branch under test) can never mark anything affected, and this
         // exit-0 note was the only sign (CI persona, 2026-09-16). Say so.
         const self = includes.map((f) => headBase(root, f.gitSince!)).find((b) => b !== undefined)
+        // `HEAD` asked by name checks uncommitted work: "HEAD is HEAD itself"
+        // read as nonsense for a valid question.
         const hint =
-          self === undefined
+          self === undefined || (self === 'HEAD' && includes.some((f) => changedAny.has(f)))
             ? ''
-            : ` — ${self} is HEAD itself: compare with the branch you merge into (--affected=origin/main) or the previous commit (--affected=HEAD~1)`
+            : self === 'HEAD'
+              ? ' — the working tree has no change against HEAD; to compare commits, use the branch you merge into (--affected=origin/main) or the previous commit (--affected=HEAD~1)'
+              : ` — ${self} is HEAD itself: compare with the branch you merge into (--affected=origin/main) or the previous commit (--affected=HEAD~1)`
         return { empty: `nothing affected since ${refs}${hint}` }
       }
       // The diff matched and a walk or an exclusion left nothing: still the
@@ -507,7 +599,11 @@ export async function resolveFilters(
     // app, and `--affected` a `...[<base>]` nobody typed.
     const hint =
       (await unlockedHint(root, parsed, unmatched)) ?? didYouMean(unmatched, projects, tags)
-    return { error: `no projects matched filter(s): ${unmatched.join(', ')}${hint}` }
+    // Quoted, as the warning below quotes it: bare, `apq...` and the hint's
+    // full stop read `apq....` in the flat message `--format json` carries.
+    return {
+      error: `no projects matched filter(s): ${unmatched.map((f) => `"${f}"`).join(', ')}${hint}`,
+    }
   }
   // Something matched, so the run proceeds; a pattern that matched nothing
   // alongside it is still worth a line — it is probably a typo.
@@ -520,7 +616,7 @@ export async function resolveFilters(
   // Each include is a union: what `--filter other` selected runs its tasks
   // whether or not the `--affected` diff reaches them, and an exclude
   // still removes it (X-10).
-  const others = parsed.filter((f) => f.negate || f.raw !== affected)
+  const others = parsed.filter((f) => f.negate || f.raw !== affected?.filter)
   const outright =
     changes !== undefined && others.some((f) => !f.negate)
       ? [