@vzn/vx 0.0.241 → 0.0.243

package/package.json

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

package/src/cache/git-inputs.ts

@@ -847,6 +847,11 @@ export interface GitEnumeration {
   trusted: Map<string, string>
   /** Whether the worktree had uncommitted changes; null when `git status` failed. */
   dirty: boolean | null
+  /**
+   * What `git status` listed, workspace-relative: modified, staged or deleted
+   * paths (both sides of a rename) and untracked files. Null when it failed.
+   */
+  changed: readonly string[] | null
   /** Workspace-relative paths whose names are not UTF-8 (`decodeGitZ`). */
   undecodable: readonly string[]
   /** `Date.now()` before the spawns: what `trusted` says is true as of no earlier. */
@@ -1038,7 +1043,39 @@ export async function startGitEnumeration(
   if (parsedStatus !== null && parsedStatus.undecodable.size > 0) {
     undecodable.push(...stripPrefixFromSet(parsedStatus.undecodable, gitPrefix))
   }
-  return { all, trusted, dirty: worktreeDirty, undecodable, startedAtMs }
+  return {
+    all,
+    trusted,
+    dirty: worktreeDirty,
+    changed: dirty === null ? null : [...dirty, ...untracked],
+    undecodable,
+    startedAtMs,
+  }
+}
+
+/** A run's whole-tree enumeration, started on its first ask and shared after. */
+export interface LazyGitEnumeration {
+  start(): Promise<GitEnumeration>
+  /** The enumeration, once something started it. */
+  readonly started: Promise<GitEnumeration> | undefined
+}
+
+export function lazyGitEnumeration(workspaceRoot: string): LazyGitEnumeration {
+  let started: Promise<GitEnumeration> | undefined
+  return {
+    start() {
+      if (started === undefined) {
+        started = startGitEnumeration(workspaceRoot, ['.'])
+        // Its first reader may never await it (a config throws first); the
+        // one that does still sees the error.
+        started.catch(() => {})
+      }
+      return started
+    },
+    get started() {
+      return started
+    },
+  }
 }
 
 /** The partition half of `populateGitFilesCache`: store per-project slices of one enumeration. */

package/src/cache/index.ts

@@ -51,6 +51,8 @@ export {
   gitPathspecs,
   repoRootOf,
   startGitEnumeration,
+  lazyGitEnumeration,
+  type LazyGitEnumeration,
   type GitEnumeration,
 } from './git-inputs.js'
 export { LayeredCache, type RemoteCacheLayer } from './layered-cache.js'

package/src/cli/run.ts

@@ -15,7 +15,7 @@ import {
 } from '../orchestrator/index.js'
 import type { ContinueMode } from '../graph/index.js'
 import { type CachePolicy, FULL_CACHE_POLICY, parseCachePolicy } from '../cache/index.js'
-import { findCwdProject, pickTask, resolveFilters } from './select.js'
+import { findCwdSelection, pickTask, resolveFilters } from './select.js'
 import { nxTargetHint, taskNamesHere } from './task-verb.js'
 import { MAX_TIMEOUT_MS, isUserError, parseDecimalInt, machineParallelism } from '../util/index.js'
 import { formatGraphDot, formatPlanJson, formatPlanText } from './plan-format.js'
@@ -511,7 +511,7 @@ export async function resolveRunOptions(
   } else if (parsed.all) {
     projects = undefined
   } else {
-    const cwdProject = await findCwdProject(cwd)
+    const cwdProject = await findCwdSelection(cwd)
     if (!cwdProject) {
       const nx = await nxTargetHint(tasks, cwd)
       if (nx !== null) return { error: nx }
@@ -520,7 +520,8 @@ export async function resolveRunOptions(
           'not inside a project. Pass --all for every project, --filter <pattern> to filter, or run from within a project directory.',
       }
     }
-    projects = [cwdProject]
+    projects = [cwdProject.name]
+    discovered = cwdProject.discovered
   }
 
   const opts: RunOptions = {

package/src/cli/select.ts

@@ -118,7 +118,20 @@ async function loadWorkspaceProjects(cwd: string): Promise<ProjectMeta[]> {
 }
 
 export async function findCwdProject(cwd: string): Promise<string | null> {
-  const projects = await loadWorkspaceProjects(cwd)
+  return (await findCwdSelection(cwd))?.name ?? null
+}
+
+/**
+ * The project `cwd` is in, and the discovery that found it, for the run to
+ * reuse (`RunOptions.discovered`): discovering again ran every `discover`
+ * hook twice (`nx()`'s graph load and worktree key among them).
+ */
+export async function findCwdSelection(
+  cwd: string,
+): Promise<{ name: string; discovered: { root: string; projects: ProjectMeta[] } } | null> {
+  const reads: LoadReads = new Map()
+  const root = await findWorkspaceRoot(cwd, reads)
+  const projects = await discoverCliProjects(await loadWorkspace(root, reads))
   const abs = path.resolve(cwd)
   const within = (dirOf: (p: ProjectMeta) => string): string | null => {
     let best: string | null = null
@@ -137,7 +150,7 @@ export async function findCwdProject(cwd: string): Promise<string | null> {
   // so inside such a member nothing matched and a run from there was "not
   // inside a project" (item 1025). Only then are the members realpathed:
   // one syscall each, paid only by a run no plain match could place.
-  return (
+  const name =
     within((p) => p.dir) ??
     within((p) => {
       try {
@@ -146,7 +159,7 @@ export async function findCwdProject(cwd: string): Promise<string | null> {
         return p.dir
       }
     })
-  )
+  return name === null ? null : { name, discovered: { root, projects } }
 }
 
 export type FilterResolution =

package/src/orchestrator/options.ts

@@ -41,7 +41,8 @@ export interface RunOptions {
   staged?: ReadonlyMap<string, ProjectEntry>
   /**
    * The projects a selection pass in this same process discovered under
-   * `root` (`--filter`, `--affected`). The run takes them instead of
+   * `root` (`--filter`, `--affected`, the project a run from inside one
+   * is in). The run takes them instead of
    * walking the workspace again when its root is the same. One run only,
    * as `staged` is.
    */

package/src/orchestrator/plugin.ts

@@ -259,6 +259,14 @@ export interface DiscoverContext extends WorkspaceHookContext {
   readonly cacheDir: string
   /** The projects found so far: core's, then earlier plugins'. */
   readonly projects: readonly ProjectMeta[]
+  /**
+   * What `git status` lists in the workspace, workspace-relative: modified,
+   * staged or deleted paths (both sides of a rename) and untracked files;
+   * null outside a git worktree. It is the run's own enumeration, so a
+   * plugin whose answer depends on the worktree (nx()'s graph key) reads it
+   * here instead of walking the tree a second time.
+   */
+  worktreeChanges(): Promise<readonly string[] | null>
 }
 
 export interface NamedProject {

package/src/orchestrator/prepare.ts

@@ -21,7 +21,7 @@ import {
   applyGitEnumeration,
   gitPathspecs,
   startGitEnumeration,
-  type GitEnumeration,
+  lazyGitEnumeration,
 } from '../cache/index.js'
 import {
   buildPackageGraph,
@@ -54,6 +54,7 @@ import {
 } from './plugin-host.js'
 import {
   discoverProjects,
+  gitOfDiscovery,
   loadProjects,
   loadWorkspacePlugins,
   type LoadedProjects,
@@ -176,13 +177,15 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // waits: its pathspecs depend on which projects the configs pull in.
   const unscoped =
     options.projects === undefined && options.tasks.some((spec) => spec.indexOf('#') <= 0)
-  const earlyGit: Promise<GitEnumeration> | undefined = unscoped
-    ? startGitEnumeration(workspaceRoot, ['.'])
-    : undefined
-  // A broken config below throws before this is awaited; the detached
-  // handler keeps that from surfacing as an unhandled rejection (the real
-  // await further down still sees the error).
-  earlyGit?.catch(() => {})
+  // A `discover` hook that reads the worktree (nx()'s graph key) starts the
+  // whole-tree enumeration a scoped run would otherwise scope later, here or
+  // in the CLI's selection pass; the run reuses it instead of walking the
+  // tree twice (G-75).
+  const reused = options.discovered?.root === workspaceRoot ? options.discovered : undefined
+  const git =
+    (reused !== undefined ? gitOfDiscovery(reused.projects) : undefined) ??
+    lazyGitEnumeration(workspaceRoot)
+  if (unscoped) void git.start()
   const workspace = await loadWorkspace(workspaceRoot, reads)
   const { workspaceConfig, plugins } = await loadWorkspacePlugins(workspaceRoot, (m) =>
     log.status(m),
@@ -194,9 +197,9 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     ? path.resolve(options.cwd, options.cacheDir)
     : resolveCacheDir(workspaceRoot, workspaceConfig)
   const projectMetas =
-    options.discovered?.root === workspaceRoot
-      ? options.discovered.projects
-      : await discoverProjects(workspace, plugins, cacheDir, (m) => log.status(m))
+    reused !== undefined
+      ? reused.projects
+      : await discoverProjects(workspace, plugins, cacheDir, (m) => log.status(m), git)
   mark('discover projects')
 
   // SCOPED config loading: configs are programs, and evaluating 1090
@@ -377,7 +380,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       ),
     )
     const projectDirs = [...projects.values()].map((p) => p.dir)
-    const enumeration = await (earlyGit ??
+    const enumeration = await (git.started ??
       startGitEnumeration(
         workspaceRoot,
         gitPathspecs(workspaceRoot, projectDirs, usesWorkspaceInputs),

package/src/orchestrator/projects.ts

@@ -18,7 +18,7 @@ import {
   type Workspace,
 } from '../workspace/index.js'
 import type { WorkspaceConfig } from '../config.js'
-import { Cache } from '../cache/index.js'
+import { Cache, lazyGitEnumeration, type LazyGitEnumeration } from '../cache/index.js'
 import { UserError } from '../util/index.js'
 import {
   buildPackageGraph,
@@ -56,6 +56,17 @@ export async function loadWorkspacePlugins(
   return { workspaceConfig, plugins }
 }
 
+/**
+ * The enumeration a discovery's `discover` hooks shared, by the array it
+ * returned: a run handed that array (`RunOptions.discovered`, the CLI's
+ * `--filter` pass) reuses the walk a hook started instead of a second one.
+ */
+const discoveredGit = new WeakMap<readonly ProjectMeta[], LazyGitEnumeration>()
+
+export function gitOfDiscovery(projects: readonly ProjectMeta[]): LazyGitEnumeration | undefined {
+  return discoveredGit.get(projects)
+}
+
 /**
  * The workspace's projects: core's discovery, then the plugin `discover`
  * stage. With no plugin declaring it, `listProjects` alone.
@@ -65,13 +76,21 @@ export async function discoverProjects(
   plugins: readonly VxPlugin[],
   cacheDir: string,
   warn: (message: string) => void,
+  /** The run's enumeration, which `DiscoverContext.worktreeChanges` reads (and starts). */
+  git: LazyGitEnumeration = lazyGitEnumeration(workspace.root),
 ): Promise<ProjectMeta[]> {
   const projects = await listProjects(workspace)
   if (!hasHook(plugins, 'discover')) return projects
+  discoveredGit.set(projects, git)
+  const worktreeChanges = (): Promise<readonly string[] | null> =>
+    git.start().then(
+      (e) => e.changed,
+      () => null,
+    )
   await applyDiscoverHooks(
     plugins,
     projects,
-    { workspaceRoot: workspace.root, cacheDir, warn },
+    { workspaceRoot: workspace.root, cacheDir, warn, worktreeChanges },
     (named, plugin) => namedProject(workspace, projects, named, plugin.name),
   )
   return projects.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))