@vzn/vx-migrate 0.0.646 → 0.0.649

package/src/nx/index.ts

@@ -69,7 +69,8 @@ const ROOT_GRAPH_FILE =
 export interface NxPluginOptions {
   /**
    * Where `nx.json` lives. Defaults to the workspace root; a repo whose Nx
-   * workspace sits elsewhere names the directory here.
+   * workspace sits elsewhere names the directory here, relative to the workspace
+   * root or absolute.
    */
   readonly root?: string
   /**
@@ -111,6 +112,11 @@ function refuseExecutors(executors: NxExecutors | undefined): void {
 /** The plugin: the adoption skeleton over `mapNxWorkspace`, one mapping per run. */
 export function nx(options: NxPluginOptions = {}): VxPlugin {
   refuseUnknownOptions('nx()', options, NX_PLUGIN_KEYS)
+  if (options.root === '') throw new UserError('nx() option "root" is a directory, not empty')
+  // Against the workspace root, as vx reads every path: against the cwd,
+  // `vx run` from a package dir read another directory.
+  const rootOf = (workspaceRoot: string): string =>
+    options.root === undefined ? workspaceRoot : path.resolve(workspaceRoot, options.root)
   refuseExecutors(options.executors)
   // One graph load per RUN, shared by `discover` and `project`: the run
   // hands both stages the same projects array (discover's, grown by what
@@ -134,7 +140,7 @@ export function nx(options: NxPluginOptions = {}): VxPlugin {
   return adoptionPlugin(
     import.meta,
     async (ctx) => {
-      const root = options.root ?? ctx.workspaceRoot
+      const root = rootOf(ctx.workspaceRoot)
       return mapAll(
         root,
         ctx.projects,
@@ -146,7 +152,7 @@ export function nx(options: NxPluginOptions = {}): VxPlugin {
     options.root === undefined ? ['nx.json'] : [],
     {
       async config(workspace, ctx) {
-        const root = options.root ?? ctx.workspaceRoot
+        const root = rootOf(ctx.workspaceRoot)
         const nxBaseCommit = Bun.env['NX_BASE']?.trim()
         if (nxBaseCommit) ctx.setBranch({ base: nxBaseCommit })
         if (workspace.baseBranch === undefined) {
@@ -174,7 +180,7 @@ export function nx(options: NxPluginOptions = {}): VxPlugin {
       // project, by its package.json name or else its Nx name; a name a
       // project already holds stays unattached, and the mapping says so.
       async discover(ctx) {
-        const root = options.root ?? ctx.workspaceRoot
+        const root = rootOf(ctx.workspaceRoot)
         const members = await memberProjects(ctx.workspaceRoot)
         // Core's status is the workspace's: a root elsewhere asks git itself.
         const changes = options.root === undefined ? () => ctx.worktreeChanges() : undefined
@@ -369,6 +375,10 @@ async function nxReads(
     String(process.env['NX_LOAD_DOT_ENV_FILES']),
     JSON.stringify(installed),
     await yarnrcText(root),
+    // Whether the manager runs a script's `pre` / `post` hooks (`runsScriptHooks`).
+    ...(await Promise.all(
+      ['package.json', '.npmrc', 'pnpm-workspace.yaml'].map((f) => textOf(path.join(root, f))),
+    )),
     ...notes,
   ]
 }
@@ -414,7 +424,7 @@ async function index(
   }
   if (unattached.length > 0) {
     notes.push(
-      `Nx project(s) ${unattached.join(', ')} have no workspace package to attach targets to ` +
+      `${unattached.length === 1 ? 'Nx project' : 'Nx projects'} ${unattached.join(', ')} ${unattached.length === 1 ? 'has' : 'have'} no workspace package to attach targets to ` +
         '(a package holds the name, or the directory is gone) — run those targets with nx',
     )
   }
@@ -574,10 +584,14 @@ async function graphInputKey(
   // stray write at the root (a report, a log) is not, and counting it
   // re-exported the graph on every run after it.
   // A `project.json` anywhere: a new one is a project no root lists yet.
+  // A `.gitignore` anywhere too: Nx's project walk honours each one, so an
+  // edit between project roots hides or shows a project.
   const roots = dirs.map((d) => relPosix(root, d))
   const graphFile = (p: string): boolean =>
     p === 'project.json' ||
     p.endsWith('/project.json') ||
+    p === '.gitignore' ||
+    p.endsWith('/.gitignore') ||
     roots.some((r) => r === '' || p.startsWith(`${r}/`)) ||
     (!p.includes('/') && ROOT_GRAPH_FILE.test(p))
   const listed = [

package/src/nx/nx-inputs.ts

@@ -7,8 +7,10 @@
 // (`dependentTasksOutputFiles`) is nothing; `externalDependencies` is a todo saying
 // so. Extracted from `buildTask` in item 606.
 
+import path from 'node:path'
 import { nxWorkspacePath, underProject, withProjectDir } from './nx-outputs.js'
-import { minimatchToVx } from '../glob-grammar.js'
+import type { TrackedKinds } from '../tracked-outputs.js'
+import { gluedGlobstarAsStar, minimatchToVx, nxBareGroups } from '../glob-grammar.js'
 import { shellQuote } from '../nx-command.js'
 
 export interface NxInputs {
@@ -24,8 +26,15 @@ export interface NxInputs {
    * representable in vx" (walked the Nx path, 2026-09-20).
    */
   readonly runtimeCmds: string[]
-  /** `^name` / `{ input, dependencies | projects }`: whose `name` to fold. */
-  readonly upstream: Array<{ readonly name: string; readonly of: 'deps' | readonly string[] }>
+  /**
+   * `^name` / `{ input, dependencies | projects }`: whose `name` to fold;
+   * `depsOf`, the listed projects' dependencies' rather than theirs.
+   */
+  readonly upstream: Array<{
+    readonly name: string
+    readonly of: 'deps' | readonly string[]
+    readonly depsOf?: true
+  }>
   /** `{ dependentTasksOutputFiles }` globs: keyed only through a `dependsOn` edge. */
   readonly dependentOutputs: string[]
 }
@@ -69,6 +78,8 @@ export function expandNxInputs(
     readonly rel: string
     readonly name: string
     readonly outputs?: readonly string[]
+    /** git's tracked files by directory; unknown, every output counts as ignored. */
+    readonly tracked?: (rel: string) => TrackedKinds
     /** The root package.json's dependency names: every task's key holds them. */
     readonly rootDeps?: ReadonlySet<string>
   },
@@ -99,9 +110,24 @@ export function expandNxInputs(
         }
         // Nx's file map skips gitignored files, so it hashes nothing here
         // either: a changed `dist` file is a cache hit under Nx 23.3 (YL-1).
+        // An output git tracks (a generator writing into `src`) is hashed,
+        // and dropping it keyed `build` on no file (stale hit, 2026-10-28).
         const lit = withProjectDir(p, at.rel, false)
-        if (neg === '' && at.outputs?.some((o) => lit === o || lit.startsWith(`${o}/`))) return
-        const g = minimatchToVx(p, neg !== '')
+        const ignored = (o: string): boolean => {
+          if (at.tracked === undefined) return true
+          const dir = path.posix.dirname(o)
+          return (
+            at.tracked(o).files.length === 0 &&
+            !at.tracked(dir).files.includes(dir === '.' ? o : o.slice(dir.length + 1))
+          )
+        }
+        if (
+          neg === '' &&
+          at.outputs?.some((o) => (lit === o || lit.startsWith(`${o}/`)) && ignored(o))
+        )
+          return
+        const bare = nxBareGroups(p)
+        const g = bare === null ? null : minimatchToVx(gluedGlobstarAsStar(bare), neg !== '')
         if (g === null) {
           todos.push(`input ${JSON.stringify(entry)}: glob syntax vx cannot take — map manually`)
           return
@@ -115,7 +141,7 @@ export function expandNxInputs(
             ? null
             : underProject(g, at.rel)
         if (own === null) into.wsFiles.push(neg + withProjectDir(g, at.rel, true))
-        else into.files.push(neg + withProjectDir(own, at.rel, true))
+        else into.files.push(neg + (own === '' ? '**/*' : withProjectDir(own, at.rel, true)))
         return
       }
       // Bare string = named-input reference.
@@ -199,17 +225,26 @@ export function expandNxInputs(
         // Nx 23 still reads the pre-17 spellings `projects: "dependencies"`
         // (`^input`) and `projects: "self"` (the project's own); taken as
         // project names, each was a todo and the input was dropped.
-        if (o.dependencies === true || o.projects === 'dependencies') {
+        const listed =
+          o.projects !== undefined && o.projects !== 'self' && o.projects !== 'dependencies'
+        if (o.projects === 'dependencies' || (o.dependencies === true && !listed)) {
           into.upstream.push({ name: o.input, of: 'deps' })
           return
         }
-        if (o.projects !== undefined && o.projects !== 'self') {
+        if (listed) {
           const of = typeof o.projects === 'string' ? [o.projects] : o.projects
           if (!Array.isArray(of) || !of.every((p) => typeof p === 'string')) {
             todos.push(`input ${JSON.stringify(entry)} not representable in vx`)
             return
           }
-          into.upstream.push({ name: o.input, of: of as string[] })
+          // Beside `projects`, Nx 24 reads `dependencies: true` as those
+          // projects' dependencies and Nx 23 as this project's: read as
+          // this project's alone, a listed project's dependency edit was a
+          // hit under Nx 24. Both are keyed, never less than either.
+          if (o.dependencies === true) {
+            into.upstream.push({ name: o.input, of: 'deps' })
+            into.upstream.push({ name: o.input, of: of as string[], depsOf: true })
+          } else into.upstream.push({ name: o.input, of: of as string[] })
           return
         }
         expand(o.input, seen)

package/src/nx/nx-map.ts

@@ -20,12 +20,14 @@ import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { type Duration, type GeneratedProject, type GeneratedTask, UserError } from '@vzn/vx'
 import type { PackageMeta } from '../packages.js'
+import { refuseTaskNames } from '../plugin-gaps.js'
 import { withoutTakenBack } from '../glob-grammar.js'
 import { manifestGraph, type ManifestGraph } from '../manifest-graph.js'
 import { mapRunCommands, shellQuote } from '../nx-command.js'
-import { scriptCommand, yarnPnp } from '../script-command.js'
+import { type Owner, runsScriptHooks, scriptCommand, yarnPnp, yarnRun } from '../script-command.js'
 import {
   ownFileTakeBacks,
+  takingBack,
   excludeSiblingOutputs,
   excludeWorkspaceOutputs,
   resolveSharedOutputs,
@@ -274,6 +276,8 @@ type MapOpts = MapNxOptions & {
   /** The root TypeScript config Nx folds into every task's hash, if any. */
   readonly rootTsConfig: string | undefined
   readonly pnp: boolean
+  /** Whether the manager owning a directory runs `pre` / `post` hooks (`runsScriptHooks`). */
+  readonly hooks: (dir: string) => boolean
   /** Tasks per `syncGenerators` list, said once in the notes. */
   readonly syncTasks: Map<string, number>
 }
@@ -325,6 +329,7 @@ export async function mapNxWorkspace(
   const g = graph
 
   const { namedInputs, cacheable, globalSync } = await readNxJsonFacts(root)
+  const hookMemo = new Map<string, Owner>()
   const mapOpts: MapOpts = {
     ...opts,
     cacheable: new Set([...opts.cacheable, ...cacheable]),
@@ -333,6 +338,7 @@ export async function mapNxWorkspace(
       existsSync(path.join(root, f)),
     ),
     pnp: yarnPnp(root),
+    hooks: (dir) => runsScriptHooks(dir, hookMemo) !== null,
     syncTasks: new Map(),
   }
 
@@ -362,6 +368,8 @@ export async function mapNxWorkspace(
     const relRoot = normRel(node?.data?.root ?? '')
     if (node?.data?.targets === undefined) continue
     const dir = relRoot === '' || relRoot === '.' ? root : path.join(root, relRoot)
+    const rel = path.relative(root, dir)
+    if (rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) continue
     let pkg: PackageMeta['packageJson'] = { name: nodeName }
     try {
       pkg = (await Bun.file(path.join(dir, 'package.json')).json()) as PackageMeta['packageJson']
@@ -386,7 +394,7 @@ export async function mapNxWorkspace(
     nodeNameOf.set(synthetic, nodeName)
   }
 
-  const upstream = planNxUpstream(nodeMap, g.dependencies, namedInputs, metaByNode)
+  const upstream = planNxUpstream(nodeMap, g.dependencies, namedInputs, metaByNode, opts.tracked)
 
   const taskNameFor: TaskNameFor = (project, target, configuration) => {
     const t = nodeMap[project]?.data?.targets?.[target]
@@ -571,7 +579,7 @@ export async function mapNxWorkspace(
         )
         followNxGraph(t.task, nodeName, meta.name, nxEdges, metaByNode, emittedIds, reached)
       }
-      dropUnheldDeps(t, emitted, emittedIds)
+      dropUnheldDeps(t, meta.name, emitted, emittedIds)
       const reader = dependentReaders.get(t)
       if (reader !== undefined && !reachesProducer(t, meta.name, emittedIds, reached)) {
         delete t.task!['cache']
@@ -615,6 +623,7 @@ export async function mapNxWorkspace(
       `\`syncGenerators\` (${gens}) on ${n} task${n === 1 ? '' : 's'}: ` +
         `Nx runs them before those targets, and vx does not — ${syncAdvice}`,
     )
+  refuseTaskNames(projects, 'target')
   return { projects, notes }
 }
 
@@ -753,6 +762,7 @@ export async function readNxJsonFacts(root: string): Promise<NxJsonFacts> {
 
 function dropUnheldDeps(
   t: GeneratedTask,
+  owner: string,
   emitted: ReadonlySet<string>,
   emittedIds: ReadonlySet<string>,
 ): void {
@@ -766,7 +776,9 @@ function dropUnheldDeps(
     if (d.startsWith('^')) return emitted.has(d.slice(1))
     // `pkg#task` on a project no package holds (the root project with no
     // vx.config) refused the whole run as "no such project".
-    if (!d.includes('#') || emittedIds.has(d)) return true
+    // A same-project target written as no task (an `nx:noop` with nothing
+    // to chain) is nothing Nx runs; kept, `vx lock` refused the project.
+    if (emittedIds.has(d.includes('#') ? d : `${owner}#${d}`)) return true
     t.todos.push(
       `dependsOn ${JSON.stringify(d)}: no vx project runs it — edge dropped, and the key misses it`,
     )
@@ -822,6 +834,7 @@ function buildTask(
     todos,
     dotenv,
     opts.pnp,
+    opts.hooks(meta.dir),
     meta.packageJson,
     opts.manifestField,
     opts.executors,
@@ -836,6 +849,7 @@ function buildTask(
     rel: projectRel,
     name: projectName,
     outputs: nxProjectOutputs(nodeMap[nodeName]?.data?.targets, projectRel, projectName),
+    ...(opts.tracked === undefined ? {} : { tracked: opts.tracked }),
     rootDeps: opts.rootDeps,
   }
   expandNxInputs(target.inputs ?? [], upstream.namedOf(nodeName), at, inputs, todos)
@@ -864,7 +878,10 @@ function buildTask(
         patterns,
         Object.entries(nodeMap).map(([name, n]) => ({
           name,
-          tags: nxTags(n),
+          // Every tag Nx matches, its own `npm:*` too: nxTags is what vx writes.
+          tags: Array.isArray(n?.data?.tags)
+            ? n.data.tags.filter((t): t is string => typeof t === 'string')
+            : [],
           ...(typeof n?.data?.root === 'string' ? { root: n.data.root } : {}),
         })),
       ),
@@ -874,6 +891,12 @@ function buildTask(
       : { node: nodeName, configuration: variant.configuration! },
     options,
   )
+  // Nx draws no edge from a task to itself (`task.id !== selfTaskId`): a
+  // `projects: "*"` or a tag the project carries named it, and vx refused
+  // the workspace as a cycle (2026-10-28).
+  for (const own of [variant.name, `${meta.name}#${variant.name}`]) {
+    for (let i = deps.indexOf(own); i !== -1; i = deps.indexOf(own)) deps.splice(i, 1)
+  }
   // A nested `nx <target>` runs the target's default configuration, whatever this one runs.
   for (const c of mapped?.nxCalls ?? []) {
     const edge =
@@ -893,7 +916,7 @@ function buildTask(
   // vx cleans outputs before a run and Nx never does. With git's file list
   // known, a wildcard-first output (`**/*.d.ts`) stays cached: core never
   // cleans a committed file, so what the clean removes is what the task
-  // writes (owner, 2026-10-03). Without it, the sources cannot be told apart.
+  // writes (2026-10-03). Without it, the sources cannot be told apart.
   const wild =
     opts.tracked === undefined
       ? (wildcardOutput(outFiles) ?? wildcardOutput(wsOutFiles))
@@ -978,7 +1001,7 @@ function buildTask(
   // dependencies again. `LERNA_PACKAGE_NAME` is the project too: Lerna
   // runs on Nx's runner and documents it to scripts. Only a command that
   // still runs Nx or Lerna gets them: a native task names no other runner
-  // (owner, 2026-10-22). A run-commands `env` still wins, as in Nx.
+  // (2026-10-22). A run-commands `env` still wins, as in Nx.
   const define = {
     ...(RUNS_NX.test(mapped.command)
       ? {
@@ -1020,8 +1043,8 @@ function buildTask(
   if (inputs.runtimeCmds.length > 0) keyed.workspaceRuntime = inputs.runtimeCmds
   task.inputs = keyed
   if (cacheEnabled) {
-    const outputs: Record<string, unknown> = { files: outFiles }
-    if (wsOutFiles.length > 0) outputs.workspaceFiles = wsOutFiles
+    const outputs: Record<string, unknown> = { files: takingBack(outFiles) }
+    if (wsOutFiles.length > 0) outputs.workspaceFiles = takingBack(wsOutFiles)
     task.cache = { outputs }
   }
 
@@ -1129,6 +1152,7 @@ function mapCommand(
   todos: string[],
   dotenv: readonly string[] | null,
   pnp: boolean,
+  hooks: boolean,
   manifest: { readonly name?: unknown; readonly version?: unknown },
   manifestField: MapNxOptions['manifestField'],
   executors: NxExecutors | undefined,
@@ -1199,10 +1223,11 @@ function mapCommand(
     // (novu's `test:watch: ""`, 2026-09-11); as a command it is a config
     // that refuses to load, so it is the placeholder with its todo.
     if (body !== undefined && body.length > 0) {
-      const command = scriptCommand(script, body, scripts, pnp)
+      // Nx runs `<pm> run <script>`: the hooks fold only where the manager runs them.
+      const command = scriptCommand(script, body, scripts, pnp, hooks)
       // `yarn run <name>` sets its own.
       const env =
-        command === `yarn run ${script}`
+        command === yarnRun(script)
           ? {}
           : npmScriptEnv(command, script, command !== body, manifest, manifestField, todos)
       return shell(command, undefined, { env, readyWhen: undefined })

package/src/nx/nx-outputs.ts

@@ -3,7 +3,7 @@
 
 import path from 'node:path'
 import { isLiteralPattern } from '@vzn/vx'
-import { literalGlob, minimatchToVx } from '../glob-grammar.js'
+import { gluedGlobstarAsStar, literalGlob, minimatchToVx, nxBareGroups } from '../glob-grammar.js'
 import { takingBack } from '../shared-outputs.js'
 
 interface NxOutputs {
@@ -59,11 +59,19 @@ export function withProjectDir(p: string, projectRel: string, asGlob: boolean):
   })
 }
 
-/** A workspace path relative to the project dir, or null when it lies outside. */
+/**
+ * A workspace path relative to the project dir, or null when it lies
+ * outside; `''` is the project dir itself, which Nx reads as the whole tree
+ * (`path_or_everything_under`). As a workspace path, `{projectRoot}` cached
+ * a literal core reads as another project's, and `{projectRoot}/` the empty
+ * path, which saved and keyed nothing.
+ */
 export function underProject(p: string, projectRel: string): string | null {
   if (projectRel === '.' || projectRel === '') return p
-  for (const dir of [masked(projectRel), projectRel])
-    if (p.startsWith(`${dir}/`)) return p.slice(dir.length + 1)
+  for (const dir of [masked(projectRel), projectRel]) {
+    if (p === dir) return ''
+    if (p.startsWith(`${dir}/`)) return p.slice(dir.length + 1).replace(/\/+$/, '')
+  }
   return null
 }
 
@@ -191,7 +199,7 @@ export function mapNxOutputs(
       const gs = g.slice(gn.length)
       const own = underProject(gs, projectRel)
       if (own !== null) {
-        outFiles.push(gn + withProjectDir(own, projectRel, true))
+        outFiles.push(gn + (own === '' ? '**' : withProjectDir(own, projectRel, true)))
         continue
       }
       const m = path.posix.normalize(gs).replace(/^\.\//, '')
@@ -215,7 +223,9 @@ export function mapNxOutputs(
  */
 function vxOutputGlobs(o: string): string[] | null {
   const negated = o.startsWith('!')
-  const segs = o.slice(negated ? 1 : 0).split('/')
+  const bare = nxBareGroups(o.slice(negated ? 1 : 0))
+  if (bare === null) return null
+  const segs = gluedGlobstarAsStar(bare).split('/')
   const at = segs.findIndex((seg) => /^!\([^()|{},]+(\|[^()|{},]+)*\)$/.test(seg))
   if (at !== -1) {
     if (negated) return null

package/src/nx/nx-upstream.ts

@@ -18,6 +18,7 @@
 // and edges only out of the cycle.
 import type { GeneratedTask } from '@vzn/vx'
 import type { PackageMeta } from '../packages.js'
+import type { TrackedKinds } from '../tracked-outputs.js'
 import { emptyNxInputs, expandNxInputs, type NxInputs } from './nx-inputs.js'
 import { nxProjectOutputs } from './nx-outputs.js'
 import { matchNxProjects } from './nx-deps.js'
@@ -72,6 +73,7 @@ export function planNxUpstream(
   dependencies: unknown,
   workspaceNamed: Readonly<Record<string, unknown[]>> | null,
   metaByNode: ReadonlyMap<string, PackageMeta>,
+  tracked?: (rel: string) => TrackedKinds,
 ): NxUpstream {
   const isProject = (n: string): boolean => typeof nodes[n]?.data?.root === 'string'
   const projectTags = Object.entries(nodes).map(([name, n]) => ({
@@ -221,6 +223,7 @@ export function planNxUpstream(
       rel,
       name: nm,
       outputs: nxProjectOutputs(nodes[node]?.data?.targets, rel || '.', nm),
+      ...(tracked === undefined ? {} : { tracked }),
     }
     expandNxInputs([name], namedOf(node), at, into, todos)
   }
@@ -289,6 +292,7 @@ export function planNxUpstream(
     into: NxInputs,
     todos: string[],
     edges: Set<string>,
+    depsOf = false,
   ): void => {
     // Nx reads the list as `dependsOn`'s `projects` (`findMatchingProjects`):
     // `*` patterns, `tag:` and `!` exclusions. Looked up as names, a
@@ -302,6 +306,10 @@ export function planNxUpstream(
     for (const p of literal)
       todos.push(`input project ${JSON.stringify(p)} is not a graph node — map manually`)
     for (const p of matchNxProjects(of, projectTags)) {
+      if (depsOf) {
+        fold(p, name, new Set(), into, todos, edges)
+        continue
+      }
       const u = { name }
       const meta = metaByNode.get(p)
       if (meta !== undefined) {
@@ -319,7 +327,7 @@ export function planNxUpstream(
     const edges = new Set<string>()
     for (const u of into.upstream) {
       if (u.of === 'deps') fold(node, u.name, new Set(), into, todos, edges)
-      else foldProjects(u.name, u.of, into, todos, edges)
+      else foldProjects(u.name, u.of, into, todos, edges, u.depsOf)
     }
     return [...edges]
   }
@@ -337,7 +345,7 @@ export function planNxUpstream(
       fold(node, name, peers, inputs, todos, edges)
       // A nested `^other` in this project's `name` input.
       for (const u of inputs.upstream) {
-        if (u.of !== 'deps') foldProjects(u.name, u.of, inputs, todos, edges)
+        if (u.of !== 'deps') foldProjects(u.name, u.of, inputs, todos, edges, u.depsOf)
         else if (u.name !== name) fold(node, u.name, peers, inputs, todos, edges)
       }
       // Nx hashes a fileset that matches nothing as nothing; core warns of