@vzn/vx 0.0.573 → 0.0.575

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.573",
+  "version": "0.0.575",
   "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.573",
-    "@vzn/vx-linux-arm64": "0.0.573",
-    "@vzn/vx-darwin-x64": "0.0.573",
-    "@vzn/vx-darwin-arm64": "0.0.573"
+    "@vzn/vx-linux-x64": "0.0.575",
+    "@vzn/vx-linux-arm64": "0.0.575",
+    "@vzn/vx-darwin-x64": "0.0.575",
+    "@vzn/vx-darwin-arm64": "0.0.575"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/why.ts

@@ -106,7 +106,7 @@ export function parseWhyArgs(args: readonly string[]): WhyArgs {
  * every recorded id (the same rule `vx run` hints with) and the hint is
  * the runnable `project#task`; an anchored query is matched whole.
  */
-function suggest(query: string, ids: readonly string[]): string {
+function suggest(query: string, ids: readonly string[], invoked: boolean): string {
   let hits: string[]
   if (query.includes('#')) {
     hits = nearMatches(query, ids)
@@ -120,9 +120,12 @@ function suggest(query: string, ids: readonly string[]): string {
   }
   if (hits.length > 0) return ` — did you mean ${hits.slice(0, 3).join(', ')}?`
   // No near name: say where to look, or that there is nothing yet.
-  return ids.length === 0
-    ? `; nothing has run here yet (vx run ${query}, then vx why)`
-    : '; `vx last --list` shows what has run'
+  // A run of only group tasks records no task row: "nothing has run" was
+  // false there, and its advice re-ran the group to the same answer.
+  if (ids.length > 0) return '; `vx last --list` shows what has run'
+  return invoked
+    ? '; no recorded run executed a task (a group records none: ask about a task it depends on)'
+    : `; nothing has run here yet (vx run ${query}, then vx why)`
 }
 
 /**
@@ -151,8 +154,9 @@ async function resolveTarget(
     .query('SELECT DISTINCT project, task FROM runs ORDER BY project, task')
     .all() as Array<{ project: string; task: string }>
   const ids = pairs.map((p) => `${p.project}#${p.task}`)
+  const invoked = ids.length === 0 && db.query('SELECT 1 FROM invocations LIMIT 1').get() !== null
   if (target.includes('#')) {
-    throw new UserError(`vx why: no recorded runs for "${target}"${suggest(target, ids)}`)
+    throw new UserError(`vx why: no recorded runs for "${target}"${suggest(target, ids, invoked)}`)
   }
   const matches = ids.filter((id) => id.endsWith(`#${target}`))
   if (matches.length === 1) return matches[0]!
@@ -164,7 +168,9 @@ async function resolveTarget(
         matches.map((m) => `  ${m}`).join('\n'),
     )
   }
-  throw new UserError(`vx why: no recorded runs for task "${target}"${suggest(target, ids)}`)
+  throw new UserError(
+    `vx why: no recorded runs for task "${target}"${suggest(target, ids, invoked)}`,
+  )
 }
 
 const fmtWhen = (ms: number): string => new Date(ms).toISOString()

package/src/graph/task-graph.ts

@@ -684,6 +684,10 @@ export function excludeDependencies(
  * 445). One rule, one place: the copy is gone.
  */
 export function outputsOverlap(rawA: string, rawB: string): boolean {
+  // A built path proves overlap only between globs as written: a literal's
+  // `/**` twin reads it as a directory, and `dist/types.d.ts` met
+  // `dist/**/*.js` at `dist/types.d.ts/x.js`, a file no one can write.
+  const bothGlobs = !isLiteralPattern(rawA) && !isLiteralPattern(rawB)
   for (const a of asTrees([rawA])) {
     for (const b of asTrees([rawB])) {
       if (isLiteralPattern(a) && isLiteralPattern(b)) {
@@ -692,7 +696,41 @@ export function outputsOverlap(rawA: string, rawB: string): boolean {
         if (taskGlob(b).match(a)) return true
       } else if (isLiteralPattern(b)) {
         if (taskGlob(a).match(b)) return true
-      } else if (a === b || covers(a, b) || covers(b, a)) return true
+      } else if (a === b || covers(a, b) || covers(b, a) || (bothGlobs && witnessed(a, b)))
+        return true
+    }
+  }
+  return false
+}
+
+/** `staticPrefix` names the project root `.`; a path built under it starts bare. */
+const rootless = (prefix: string): string => (prefix === '.' ? '' : prefix)
+
+/**
+ * Do two globs both match a path built from them? Each candidate is a
+ * real path, so a hit proves the overlap and a miss decides nothing. The
+ * path sits under the deeper of the two literal prefixes and ends in
+ * either glob's last segment with its wildcards filled: a glob for every
+ * `.js` file under `dist` beside `dist/sth/**` meets at `dist/sth/x.js`,
+ * a pair `covers` cannot decide since neither is a subtree holding the
+ * other's prefix.
+ */
+function witnessed(a: string, b: string): boolean {
+  const pa = rootless(staticPrefix(a))
+  const pb = rootless(staticPrefix(b))
+  const nested = (outer: string, inner: string): boolean =>
+    outer === '' || inner === outer || inner.startsWith(`${outer}/`)
+  if (!nested(pa, pb) && !nested(pb, pa)) return false
+  const deeper = pa.length >= pb.length ? pa : pb
+  const ga = taskGlob(a)
+  const gb = taskGlob(b)
+  for (const glob of [a, b]) {
+    const last = glob.slice(glob.lastIndexOf('/') + 1)
+    if (/[[\]{}()!+@]/.test(last)) continue
+    const leaf = last.replace(/\*+|\?/g, 'x')
+    for (const mid of ['', 'x/']) {
+      const candidate = deeper === '' ? `${mid}${leaf}` : `${deeper}/${mid}${leaf}`
+      if (ga.match(candidate) && gb.match(candidate)) return true
     }
   }
   return false
@@ -953,6 +991,19 @@ function overlapCandidates<T>(
       for (let y = x + 1; y < list.length; y++) pair(list[x]!, list[y]!)
     }
   }
+  // `witnessed`: two globs meet only when one's literal prefix is the
+  // other's or under it, so each looks up the globs filed at its prefix
+  // and at each ancestor.
+  const byPrefix = new Map<string, number[]>()
+  for (const [i, prefix] of prefixes) file(byPrefix, rootless(prefix), i)
+  for (const [i, raw] of prefixes) {
+    const prefix = rootless(raw)
+    for (const j of byPrefix.get(prefix) ?? []) pair(i, j)
+    if (prefix !== '') for (const j of byPrefix.get('') ?? []) pair(i, j)
+    for (let sep = prefix.indexOf('/'); sep !== -1; sep = prefix.indexOf('/', sep + 1)) {
+      for (const j of byPrefix.get(prefix.slice(0, sep)) ?? []) pair(i, j)
+    }
+  }
   for (const [i, prefix] of prefixes) {
     for (const j of subtrees.get(prefix) ?? []) pair(i, j)
     for (let sep = prefix.indexOf('/'); sep !== -1; sep = prefix.indexOf('/', sep + 1)) {