@vzn/vx-migrate 0.0.645 → 0.0.648

package/src/migrate.ts

@@ -3,7 +3,7 @@
 // existing Turbo or Nx setup (`--keep`: the workspace file that reads it
 // live instead), from Vite Task, or from package.json scripts, and vx
 // installed with the repo's manager. `vx init` hands every repo with a
-// package.json here (M, 2026-10-14: core reads no package.json).
+// package.json here (2026-10-14: core reads no package.json).
 // Without either mode flag a terminal is asked; anything else is native. Source auto-detect: turbo.json → Turbo;
 // .nx/workspace-data/project-graph.json, nx.json or a Lerna-on-Nx lerna.json → Nx (the resolved
 // graph, exported by nx if absent); `vite-plus` in the root package.json → Vite Task:
@@ -19,6 +19,7 @@ import path from 'node:path'
 import {
   applyMigration,
   findWorkspaceRoot,
+  isStarterConfig,
   isUserError,
   VERSION,
   type MigrationFormat,
@@ -53,14 +54,13 @@ import {
   missingPackages,
   MODE_QUESTION,
   ownVersion,
-  type PackageManager,
   packageManagerOf,
   parseModeAnswer,
   uninstall,
 } from './adopt.js'
 import { migrateTurbo } from './migrate-turbo.js'
 import { migrateViteTask } from './migrate-vite-task.js'
-import { turboConfigFile } from './turbo/turbo-map.js'
+import { turboConfigFile } from './turbo/turbo-reads.js'
 import { lockfilePlugin } from './workspace-notes.js'
 import {
   extendWorkspaceFile,
@@ -102,8 +102,10 @@ export function parseMigrateArgs(args: readonly string[]): MigrateArgs {
     else if (a === '--no-install') out.noInstall = true
     else if (a === '--format' || a?.startsWith('--format=')) {
       const v = a === '--format' ? args[++i] : a.slice('--format='.length)
+      if (v === undefined || v === '')
+        return { ...out, error: '--format requires a value: pretty or json' }
       if (v !== 'json' && v !== 'pretty') {
-        return { ...out, error: `--format must be pretty or json (got ${v ?? 'nothing'})` }
+        return { ...out, error: `--format must be pretty or json (got ${v})` }
       }
       out.json = v === 'json'
     } else if (a === '--native' || a === '--keep') {
@@ -114,8 +116,10 @@ export function parseMigrateArgs(args: readonly string[]): MigrateArgs {
       out.mode = mode
     } else if (a === '--from' || a?.startsWith('--from=')) {
       const v = a === '--from' ? args[++i] : a.slice('--from='.length)
+      if (v === undefined || v === '')
+        return { ...out, error: '--from requires a value: turbo, nx, vite-task or scripts' }
       if (v !== 'turbo' && v !== 'nx' && v !== 'vite-task' && v !== 'scripts') {
-        return { ...out, error: '--from must be turbo, nx, vite-task or scripts' }
+        return { ...out, error: `--from must be turbo, nx, vite-task or scripts (got ${v})` }
       }
       out.from = v
     } else if (a === '--help' || a === '-h') return { ...out, help: true }
@@ -144,13 +148,11 @@ async function noRootReason(cwd: string, err: Error): Promise<Error> {
 export async function migrateCmd(args: readonly string[]): Promise<number> {
   const parsed = parseMigrateArgs(args)
   if (parsed.help) {
-    process.stdout.write(`${USAGE}\n`)
+    ui.say('info', USAGE, 'out')
     return 0
   }
-  if (parsed.error) {
-    process.stderr.write(`vx-migrate: ${parsed.error}\n`)
-    return 1
-  }
+  // Thrown, so the bin answers it as JSON too when that was asked.
+  if (parsed.error) throw new UserError(parsed.error, 'VX_E_USAGE')
   const reads: LoadReads = new Map()
   // An Nx repo with no package.json (Nx pinned in `.nx/installation`):
   // nothing is installable, so its configs run on core alone.
@@ -163,7 +165,13 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
   })
   const workspace = bare ? { root, packageGlobs: [] } : await loadPackageWorkspace(root, reads)
   const nameless: string[] = []
-  const metas = bare ? [] : await discoverPackages(workspace, nameless)
+  // `vx init`'s starter at the root holds no task: mapped as if absent, so
+  // the root's own scripts become its tasks.
+  const metas = bare
+    ? []
+    : (await discoverPackages(workspace, nameless)).filter(
+        (m) => !(m.dir === root && m.configPath !== null && isStarterConfig(m.configPath)),
+      )
 
   const turboFile = await turboConfigFile(root)
   const hasTurbo = turboFile !== null
@@ -358,7 +366,7 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
   // adoption's install of it is dropped with turbo() / nx().
   const finalWorkspace = workspaceText ?? readFileSync(path.join(root, existingWorkspace!), 'utf8')
   // Imports parsed, not matched: a formatter's double quotes hid it, and
-  // the file still imported the package removed (owner, 2026-10-16).
+  // the file still imported the package removed (2026-10-16).
   const imported = importedPackages(finalWorkspace)
   const needsSelf = runsBins || imported.includes('@vzn/vx-migrate')
   const cacheNote =
@@ -386,7 +394,7 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
             needsSelf ? [] : ['@vzn/vx-migrate'],
           )),
         ]
-  return applyMigration({
+  const code = await applyMigration({
     root,
     metas,
     plan,
@@ -401,6 +409,7 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
     // The written workspace file imports plugins `--no-install` left out.
     ...(parsed.noInstall === true ? {} : { lock: lockWorkspace }),
   })
+  return exitAfter(code, steps)
 }
 
 /**
@@ -418,8 +427,10 @@ async function lockWorkspace(root: string): Promise<{ code: number; said: string
     p.exited,
   ])
   // A success's warnings print above the report; a refusal is said whole.
+  // A success is a report row, matched as text: the colour FORCE_COLOR
+  // gave the child would hide its `✓ vx lock` mark from that match.
   if (code === 0) process.stderr.write(err)
-  return { code, said: code === 0 ? out : out + err }
+  return { code, said: code === 0 ? Bun.stripANSI(out) : out + err }
 }
 
 /** A report row: what the tool did, e.g. `['ran', 'bun add -d …']`. */
@@ -500,17 +511,36 @@ async function prepareRepo(
   const missing = missingPackages(root, all, version)
   if (missing.length > 0) {
     steps.push(
-      args.dry ? ['install', missing.join(' ')] : ['ran', await install(root, missing, version)],
+      args.dry ? ['install', missing.join(' ')] : await ran(() => install(root, missing, version)),
     )
   }
   // Last: the package removed may be the one running this.
   const listed = listedPackages(root, unwanted)
   if (listed.length > 0) {
-    steps.push(args.dry ? ['remove', listed.join(' ')] : ['ran', await uninstall(root, listed)])
+    steps.push(args.dry ? ['remove', listed.join(' ')] : await ran(() => uninstall(root, listed)))
   }
   return steps
 }
 
+/**
+ * A manager step's row. Its failure is a `failed` row, not the end of the
+ * migration: the configs are still written and the report names what to
+ * re-run, where a throw left a repo with neither.
+ */
+async function ran(step: () => Promise<string>): Promise<Step> {
+  try {
+    return ['ran', await step()]
+  } catch (e) {
+    if (!isUserError(e)) throw e
+    return ['failed', e.message]
+  }
+}
+
+/** The exit a migration ends with: 1 when a manager step failed, whatever the rest did. */
+function exitAfter(code: number, steps: readonly Step[]): number {
+  return code === 0 && steps.some(([label]) => label === 'failed') ? 1 : code
+}
+
 /**
  * `--keep`: `.vx/workspace.ts` declaring `turbo()` or `nx()`, so the
  * runner's own config stays the source, beside the plugins the repo calls
@@ -554,7 +584,7 @@ async function keep(
     args,
   )
   if (args.json)
-    for (const [label, value] of steps) process.stderr.write(`vx-migrate: ${label}: ${value}\n`)
+    for (const [label, value] of steps) ui.say('info', `vx-migrate: ${label}: ${value}`)
   const ignore = existsSync(path.join(root, '.vx', '.gitignore')) ? [] : ['.vx/.gitignore']
   if (!args.dry) {
     if (before === undefined) {
@@ -603,7 +633,7 @@ async function keep(
     )
     return 0
   }
-  if (args.dry && before === undefined) process.stdout.write(`── ${name} ──\n${text}\n`)
+  if (args.dry && before === undefined) ui.print('out', ui.excerpt(name, text))
   // A run reads only the lock; with the plugins installed it is written
   // now, else `next` names `vx lock` after the install.
   const lock = !args.dry && !next.includes(' lock && ') ? await lockWorkspace(root) : undefined
@@ -626,7 +656,7 @@ async function keep(
     ],
   ]
   ui.print('out', ui.report(`vx-migrate ${VERSION}`, rows))
-  return lock?.code ?? 0
+  return exitAfter(lock?.code ?? 0, steps)
 }
 
 /** `vx lock`'s outcome as the report's row. */
@@ -642,14 +672,6 @@ function lockRow(lock: { code: number; said: string }): ui.FieldRow {
 /** `.vx/.gitignore`'s text, as core writes it: the machine-local cache and restore staging stay out of git. */
 const DOT_VX_GITIGNORE = '/cache\n/tmp\n'
 
-// npx and bunx name the package: their bare `vx` is a stranger's npm package.
-const EXEC: Record<PackageManager, string> = {
-  pnpm: 'pnpm vx',
-  yarn: 'yarn vx',
-  bun: 'bunx @vzn/vx',
-  npm: 'npx @vzn/vx',
-}
-
 /**
  * Install what the workspace file imports, if missing, then run the repo's
  * build. Pinned to this release: every @vzn package releases in lockstep,
@@ -666,12 +688,12 @@ export function adoptionNext(
   const missing = needs.filter(
     (p) => !existsSync(path.join(root, 'node_modules', p, 'package.json')),
   )
-  // A global vx (no runner started this one) runs the workspace's plugins as they are.
-  const vx = process.env['npm_config_user_agent'] === undefined ? 'vx' : EXEC[pm]
-  const run = `${vx} run ${firstTask(path.join(root, source), runner)} --all`
+  // `vx init` installs vx globally first: vx alone, never a package
+  // manager's runner (2026-10-22: vx owns the command).
+  const run = `vx run ${firstTask(path.join(root, source), runner)} --all`
   if (missing.length === 0) return run
   const pinned = version === null ? missing : missing.map((p) => `${p}@${version}`)
-  return `${installArgv(root, pm, pinned).join(' ')} && ${vx} lock && ${run}`
+  return `${installArgv(root, pm, pinned).join(' ')} && vx lock && ${run}`
 }
 
 /**
@@ -696,7 +718,7 @@ function firstTask(file: string, runner: 'turbo' | 'nx'): string {
 /**
  * package.json scripts → one vx.config.ts per package, and the workspace
  * file declaring the lockfile plugin its lockfile calls for: `vx init`'s
- * mapper until core stopped reading package.json (M, 2026-10-14).
+ * mapper until core stopped reading package.json (2026-10-14).
  */
 async function scripts(
   root: string,
@@ -734,12 +756,8 @@ async function scripts(
           `the workspace globs (${globs.map((g) => `"${g}"`).join(', ')}) match no package.json: add a package under one, or fix the glob`,
         ]
       : []
-  const installed = await prepareRepo(
-    root,
-    plugins.map((p) => p.pkg),
-    args,
-  )
-  return applyMigration({
+  const installed = await prepareRepo(root, [...new Set(plugins.map((p) => p.pkg))], args)
+  const code = await applyMigration({
     root,
     metas,
     plan,
@@ -757,6 +775,7 @@ async function scripts(
     plugins,
     ...(args.noInstall === true ? {} : { lock: lockWorkspace }),
   })
+  return exitAfter(code, installed)
 }
 
 /**

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)