@vzn/vx 0.0.29 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.29",
-    "@vzn/vx-linux-arm64": "0.0.29",
-    "@vzn/vx-darwin-x64": "0.0.29",
-    "@vzn/vx-darwin-arm64": "0.0.29"
+    "@vzn/vx-linux-x64": "0.0.31",
+    "@vzn/vx-linux-arm64": "0.0.31",
+    "@vzn/vx-darwin-x64": "0.0.31",
+    "@vzn/vx-darwin-arm64": "0.0.31"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/run.ts

@@ -461,6 +461,7 @@ export async function resolveRunOptions(
   const anchoredTasks = tasks.filter((t) => t.includes('#'))
   let projects: string[] | undefined
   let staged: RunOptions['staged']
+  let selectedByDiff = false
   if (bareTasks.length === 0) {
     projects = undefined
   } else if (filterStrings.length > 0) {
@@ -480,6 +481,7 @@ export async function resolveRunOptions(
       projects = []
     } else {
       projects = resolved.names
+      selectedByDiff = resolved.byDiff
       // The graph walk staged every config; the run reuses those entries
       // instead of evaluating and staging them a second time.
       staged = resolved.staged
@@ -515,6 +517,7 @@ export async function resolveRunOptions(
     opts.excludeDependencies = parsed.excludeDependencies
   }
   if (projects !== undefined) opts.projects = projects
+  if (selectedByDiff) opts.selectedByDiff = true
   if (staged !== undefined) opts.staged = staged
   if (parsed.retries !== undefined) opts.retries = parsed.retries
   if (parsed.timeout !== undefined) opts.timeout = parsed.timeout
@@ -582,6 +585,10 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       return 1
     }
     if (plan.tasks.length === 0) {
+      if (opts.selectedByDiff === true) {
+        process.stderr.write(`vx run: no affected project declares task(s): ${tasks.join(', ')}.\n`)
+        return 0
+      }
       process.stderr.write(`vx run: no projects declare task(s): ${tasks.join(', ')}.\n`)
       return 1
     }

package/src/cli/select.ts

@@ -5,6 +5,7 @@
 
 import readline from 'node:readline/promises'
 import path from 'node:path'
+import fs from 'node:fs'
 import {
   affectedProjects,
   refIsHead,
@@ -115,18 +116,40 @@ async function loadWorkspaceProjects(cwd: string): Promise<ProjectMeta[]> {
 export async function findCwdProject(cwd: string): Promise<string | null> {
   const projects = await loadWorkspaceProjects(cwd)
   const abs = path.resolve(cwd)
-  let best: ProjectMeta | null = null
-  for (const p of projects) {
-    if (abs === p.dir || abs.startsWith(p.dir + path.sep)) {
-      if (!best || p.dir.length > best.dir.length) best = p
+  const within = (dirOf: (p: ProjectMeta) => string): string | null => {
+    let best: string | null = null
+    let bestLength = -1
+    for (const p of projects) {
+      const dir = dirOf(p)
+      if ((abs === dir || abs.startsWith(dir + path.sep)) && dir.length > bestLength) {
+        best = p.name
+        bestLength = dir.length
+      }
     }
+    return best
   }
-  return best?.name ?? null
+  // The cwd is a real path (the kernel's), and a member discovery reached
+  // through a link keeps the link's (`packages/b -> ../ext/b`, item 987),
+  // 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 (
+    within((p) => p.dir) ??
+    within((p) => {
+      try {
+        return fs.realpathSync(p.dir)
+      } catch {
+        return p.dir
+      }
+    })
+  )
 }
 
 export type FilterResolution =
   | {
       names: string[]
+      /** An include filter was a git diff (`[ref]`, `--affected`): `RunOptions.selectedByDiff`. */
+      byDiff: boolean
       /** The staged load the graph walk needed, for the run to reuse (`RunOptions.staged`). */
       staged?: ReadonlyMap<string, ProjectEntry>
     }
@@ -269,7 +292,11 @@ export async function resolveFilters(
       staged = undefined
     }
   }
-  return { names: [...selected].sort(), ...(staged !== undefined ? { staged } : {}) }
+  return {
+    names: [...selected].sort(),
+    byDiff: parsed.some((f) => !f.negate && f.gitSince !== undefined),
+    ...(staged !== undefined ? { staged } : {}),
+  }
 }
 
 export interface PickedTask {

package/src/orchestrator/options.ts

@@ -20,6 +20,15 @@ export interface RunOptions {
    */
   tasks: readonly string[]
   projects?: string[]
+  /**
+   * `projects` came from a git diff (`--affected`, a `[ref]` filter), so
+   * which projects hold a bare task name depends on what changed: a name
+   * the changed projects do not declare is not a typo when the workspace
+   * declares it elsewhere, and a run with nothing left to do is clean.
+   * Judged against the scope, a docs-only commit turned
+   * `vx run test --affected` red (item 1024).
+   */
+  selectedByDiff?: boolean
   /**
    * Configs a selection pass in this same process already loaded and
    * staged with the same `cacheDir` and `frozen` (the CLI walks every

package/src/orchestrator/prepare.ts

@@ -131,11 +131,14 @@ export interface PreparedRun {
    *     user's task names were resolved against `projects`. Typically
    *     a typo'd task name; `run()` treats this as a CI footgun and
    *     returns NOT-ok.
+   *   - `'none-affected'`     — as `'no-tasks-declared'`, but the scope
+   *     came from a diff and every name is declared somewhere else in the
+   *     workspace: nothing changed that runs them, a clean outcome.
    *   - `'empty-graph'`       — `requested` was non-empty but the
    *     graph builder still produced no nodes. Defensive; unreachable
    *     under current `buildTaskGraph` semantics.
    */
-  empty: null | 'no-tasks-declared' | 'empty-graph'
+  empty: null | 'no-tasks-declared' | 'none-affected' | 'empty-graph'
 }
 
 /**
@@ -286,7 +289,16 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     : [...projects.keys()]
 
   const requested = expandRequested(options.tasks, candidateProjects, projects)
-  const unresolvedTasks = unresolvedRequests(options.tasks, candidateProjects, projects)
+  let unresolvedTasks = unresolvedRequests(options.tasks, candidateProjects, projects)
+  if (
+    options.selectedByDiff === true &&
+    projects.size < projectsWithConfigs.length &&
+    unresolvedTasks.some((t) => !t.includes('#'))
+  ) {
+    unresolvedTasks = await declaredNowhere(unresolvedTasks, () =>
+      loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),
+    )
+  }
 
   // Cache seam precedence: an EXPLICITLY injected remote layer
   // (RunOptions.remoteCache — a distribution agent or daemon that already
@@ -369,7 +381,10 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       gitFilesCache,
       hashCache,
       workspaceProjectCount: projectMetas.length,
-      empty: 'no-tasks-declared',
+      empty:
+        options.selectedByDiff === true && unresolvedTasks.length === 0
+          ? 'none-affected'
+          : 'no-tasks-declared',
     }
   }
 
@@ -460,6 +475,29 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   }
 }
 
+/**
+ * The names in `unresolved` no project in the whole workspace declares: an
+ * anchored `pkg#task` stays as it is, a bare name leaves when a config the
+ * diff's scope left out declares it. `load` evaluates those configs; one
+ * failing to load leaves every name as it was, so the guard still speaks.
+ */
+async function declaredNowhere(
+  unresolved: readonly string[],
+  load: () => Promise<LoadedProjects>,
+): Promise<string[]> {
+  let all: LoadedProjects
+  try {
+    all = await load()
+  } catch {
+    return [...unresolved]
+  }
+  const declared = new Set<string>()
+  for (const p of all.projects.values()) {
+    for (const t of Object.keys(p.config.tasks ?? {})) declared.add(t)
+  }
+  return unresolved.filter((t) => t.includes('#') || !declared.has(t))
+}
+
 /**
  * Refuses the first `^name` in `unproven` that no project in the whole
  * workspace declares. `load` evaluates the configs a scoped run left out;

package/src/orchestrator/run.ts

@@ -259,6 +259,12 @@ async function runOnBus(
     prepared.cache.close()
     return { ok: false, outcomes: [] }
   }
+  if (prepared.empty === 'none-affected') {
+    log.status(`No affected project declares task(s): ${options.tasks.join(', ')}.`)
+    await teardown()
+    prepared.cache.close()
+    return { ok: true, outcomes: [] }
+  }
   if (prepared.empty !== null) {
     // `no-tasks-declared` is almost always a typo in CI; we surface
     // a clear message and return NOT-ok so the script exits 1.