@vzn/vx-migrate 0.0.636 → 0.0.638

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@vzn/vx-migrate",
-  "version": "0.0.636",
+  "version": "0.0.638",
   "license": "MIT",
-  "description": "Adopt @vzn/vx from Turborepo or Nx: run the repo unchanged, migrate it to vx.config.ts, and keep your Turbo or Nx remote cache",
+  "description": "Adopt @vzn/vx from Turborepo, Nx or package.json scripts: run the repo unchanged, migrate it to vx.config.ts, and keep your Turbo or Nx remote cache",
   "keywords": [
     "vx",
     "vx-plugin",
@@ -40,7 +40,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@vzn/vx": "^0.0.636"
+    "@vzn/vx": "^0.0.638"
   },
   "repository": {
     "type": "git",

package/src/adopt.ts

@@ -152,7 +152,7 @@ export function listedPackages(root: string, packages: readonly string[]): strin
   )
 }
 
-/** Install `packages` (at `version`, given one) with the repo's manager, its output on the terminal. */
+/** Install `packages` (at `version`, given one) with the repo's manager; its output only on failure. */
 export function install(
   root: string,
   packages: readonly string[],
@@ -164,7 +164,7 @@ export function install(
     installArgv(root, pm, version === null ? packages : packages.map((p) => `${p}@${version}`)),
     'installing vx',
     // pnpm 12 refuses a version younger than minimumReleaseAge, and vx
-    // releases daily; its words scroll by above, so the way out is named.
+    // releases daily; its words print above, so the way out is named.
     pm === 'pnpm'
       ? `; if pnpm refused a version published within its minimumReleaseAge, list ${packages.join(', ')} under minimumReleaseAgeExclude in pnpm-workspace.yaml`
       : '',
@@ -206,11 +206,26 @@ async function runManager(
   ranHint = '',
 ): Promise<string> {
   const line = argv.join(' ')
-  process.stdout.write(`vx-migrate: ${line}\n`)
-  const spawn = (cmd: string[]) =>
-    Bun.spawn(cmd, { cwd: root, stdio: ['inherit', 'inherit', 'inherit'] }).exited
+  // The report's `install` row says what ran; a terminal sees it while it
+  // runs, on a line the report then takes the place of.
+  const live = process.stdout.isTTY === true
+  if (live) process.stdout.write(`\n  ${line.slice(0, (process.stdout.columns ?? 80) - 4)} …`)
+  // The manager's own output (progress, deprecations, audit, postinstalls)
+  // is shown only when it fails: mid-init it buried the report (Growth's
+  // first-run funnel F3, 2026-10-13).
+  let said = ''
+  const spawn = async (cmd: string[]) => {
+    const p = Bun.spawn(cmd, { cwd: root, stdin: 'inherit', stdout: 'pipe', stderr: 'pipe' })
+    const [out, err, code] = await Promise.all([
+      new Response(p.stdout).text(),
+      new Response(p.stderr).text(),
+      p.exited,
+    ])
+    said = out + err
+    return code
+  }
   let code: number
-  let why = ''
+  let failed = ''
   try {
     code = await spawn(argv)
   } catch (e) {
@@ -220,12 +235,14 @@ async function runManager(
       code = await spawn(launcher)
     } catch (e2) {
       code = -1
-      why = `: ${(e2 as Error).message}`
+      failed = `: ${(e2 as Error).message}`
     }
   }
+  if (live) process.stdout.write('\r\x1b[2K\x1b[1A')
   if (code !== 0) {
+    process.stderr.write(said)
     throw new UserError(
-      `${what} failed (${line} exited ${code}${why}); run it, then vx-migrate again${code > 0 ? ranHint : ''}`,
+      `${what} failed (${line} exited ${code}${failed}); run it, then vx-migrate again${code > 0 ? ranHint : ''}`,
     )
   }
   return line

package/src/adoption-plugin.ts

@@ -29,7 +29,7 @@ async function spare(
     if (ids === undefined) todos.set(todo, (ids = []))
     ids.push(id)
   }
-  return { byName: mapping.byName, gaps: { notes: mapping.gaps.notes, todos } }
+  return { byName: mapping.byName, gaps: { ...mapping.gaps, todos } }
 }
 
 /**
@@ -97,7 +97,7 @@ export function adoptionPlugin(
       const mapped = await mapping!
       if (!warned) {
         warned = true
-        warnGaps(ctx.warn, plugin.name, mapped.gaps)
+        warnGaps(ctx.warn, plugin.name, mapped.gaps, ctx.lock)
       }
       const project = mapped.byName.get(ctx.name)
       if (project === undefined) return

package/src/manifest-graph.ts

@@ -0,0 +1,65 @@
+// The workspace edges the mappers reason about. Core reads no manifest
+// edge: a run's `^task` follows a plugin's (`@vzn/vx-lockfile`'s, from the
+// lockfile the manager wrote from these manifests). Turbo and Nx draw
+// package edges from the same manifests, so the mappers read them here: a
+// dependency, dev or optional entry whose key names a workspace package
+// orders it; a peer on one only reaches it.
+
+import type { PackageMeta } from './packages.js'
+
+export interface ManifestGraph {
+  /** Packages this one builds after, sorted. */
+  directDeps(name: string): readonly string[]
+  /** Every package a change reaches this one through, sorted. */
+  transitiveDeps(name: string): readonly string[]
+  /** Every package a change here reaches, sorted. */
+  transitiveDependents(name: string): readonly string[]
+}
+
+const ORDER_FIELDS = ['dependencies', 'devDependencies', 'optionalDependencies'] as const
+
+export function manifestGraph(metas: readonly PackageMeta[]): ManifestGraph {
+  const names = new Set(metas.map((m) => m.name))
+  const order = new Map<string, string[]>()
+  const reach = new Map<string, string[]>()
+  const dependents = new Map<string, string[]>()
+  const keys = (field: unknown): string[] =>
+    field !== null && typeof field === 'object' ? Object.keys(field) : []
+  for (const m of metas) {
+    const pkg = m.packageJson as unknown as Record<string, unknown>
+    const own = new Set<string>()
+    for (const f of ORDER_FIELDS) for (const k of keys(pkg[f])) if (names.has(k)) own.add(k)
+    own.delete(m.name)
+    const all = new Set(own)
+    for (const k of keys(pkg['peerDependencies'])) if (names.has(k) && k !== m.name) all.add(k)
+    order.set(m.name, [...own].sort())
+    reach.set(m.name, [...all].sort())
+    for (const d of all) {
+      const list = dependents.get(d)
+      if (list === undefined) dependents.set(d, [m.name])
+      else list.push(m.name)
+    }
+  }
+  const closure = (edges: ReadonlyMap<string, readonly string[]>) => {
+    const memo = new Map<string, readonly string[]>()
+    return (name: string): readonly string[] => {
+      let out = memo.get(name)
+      if (out !== undefined) return out
+      const seen = new Set<string>()
+      const stack = [...(edges.get(name) ?? [])]
+      while (stack.length > 0) {
+        const n = stack.pop()!
+        if (seen.has(n)) continue
+        seen.add(n)
+        stack.push(...(edges.get(n) ?? []))
+      }
+      memo.set(name, (out = [...seen].sort()))
+      return out
+    }
+  }
+  return {
+    directDeps: (name) => order.get(name) ?? [],
+    transitiveDeps: closure(reach),
+    transitiveDependents: closure(dependents),
+  }
+}

package/src/manifests.ts

@@ -0,0 +1,52 @@
+// Core reads no `package.json`: a project is a directory with a vx.config,
+// named by its config, a `discover` plugin or its path. A Turbo or Nx repo
+// writes no vx.config, so its projects are the package manager's members,
+// which `discover` names here (`memberProjects`). The mappers read scripts,
+// names and dependencies, so each project's manifest is read here once
+// per run: the members' as `discover` lists them, the rest once per
+// projects array (core hands every `project` call of a run the same one).
+import path from 'node:path'
+import { type DiscoveredProject, type ProjectMeta } from '@vzn/vx'
+import { listPackages, type PackageMeta } from './packages.js'
+
+/** The manifests the last `discover` read, by directory. */
+let listed = new Map<string, PackageMeta>()
+const read = new WeakMap<readonly ProjectMeta[], Promise<PackageMeta[]>>()
+
+/**
+ * The package manager's members at `root` as `discover` entries, each
+ * named by its `package.json`; none where the root holds no
+ * `package.json` or `pnpm-workspace.yaml`.
+ */
+export async function memberProjects(root: string): Promise<DiscoveredProject[]> {
+  const exists = await Promise.all(
+    ['package.json', 'pnpm-workspace.yaml'].map((f) => Bun.file(path.join(root, f)).exists()),
+  )
+  const members = exists.some(Boolean) ? await listPackages(root) : []
+  listed = new Map(members.map((m) => [path.resolve(m.dir), m]))
+  return members.map((m) => ({ dir: m.dir, name: m.name }))
+}
+
+/** `metas` with each one's `package.json` (`{ name }` where it has none or it does not parse). */
+export function withManifests(metas: readonly ProjectMeta[]): Promise<PackageMeta[]> {
+  let out = read.get(metas)
+  if (out === undefined) {
+    out = Promise.all(metas.map(withManifest))
+    read.set(metas, out)
+  }
+  return out
+}
+
+async function withManifest(meta: ProjectMeta): Promise<PackageMeta> {
+  const known = listed.get(path.resolve(meta.dir))
+  const pkg: unknown =
+    known?.packageJson ??
+    (await Bun.file(path.join(meta.dir, 'package.json'))
+      .json()
+      .catch(() => null))
+  const packageJson =
+    pkg !== null && typeof pkg === 'object' && !Array.isArray(pkg)
+      ? (pkg as PackageMeta['packageJson'])
+      : { name: meta.name }
+  return { name: meta.name, dir: meta.dir, configPath: meta.configPath, packageJson }
+}

package/src/mapping-cache.ts

@@ -10,13 +10,7 @@
 
 import { mkdir, rename } from 'node:fs/promises'
 import path from 'node:path'
-import {
-  buildPackageGraph,
-  foldScriptHooks,
-  isLiteralPattern,
-  outputsOverlap,
-  VERSION,
-} from '@vzn/vx'
+import { foldScriptHooks, isLiteralPattern, outputsOverlap, VERSION } from '@vzn/vx'
 import type { Gaps } from './plugin-gaps.js'
 
 /** What the stage uses of a mapping: tags and tasks per package name, and the gaps to report once. */
@@ -41,7 +35,7 @@ function codeId(): Promise<string> {
   code ??= (async () => {
     const parts: string[] = [
       VERSION,
-      ...[buildPackageGraph, foldScriptHooks, isLiteralPattern, outputsOverlap].map(String),
+      ...[foldScriptHooks, isLiteralPattern, outputsOverlap].map(String),
     ]
     const files: string[] = []
     for await (const f of new Bun.Glob('**/*.{ts,cjs}').scan(import.meta.dir)) files.push(f)
@@ -67,6 +61,7 @@ interface Held {
   ][]
   readonly notes: string[]
   readonly todos: [string, string[]][]
+  readonly live: string[]
 }
 
 /** `map()`, or the mapping it returned last under the same `parts`. */
@@ -84,7 +79,7 @@ export async function cachedMapping(
   if (held?.key === key) {
     return {
       byName: new Map(held.byName),
-      gaps: { notes: held.notes, todos: new Map(held.todos) },
+      gaps: { notes: held.notes, todos: new Map(held.todos), live: held.live },
     }
   }
   const mapping = await map()
@@ -99,6 +94,7 @@ export async function cachedMapping(
     ]),
     notes: [...mapping.gaps.notes],
     todos: [...mapping.gaps.todos].map(([todo, ids]) => [todo, [...ids]]),
+    live: [...mapping.gaps.live],
   }
   // Best-effort, and whole or absent: a reader never sees half a file, and
   // a cache dir it cannot write costs the next run a mapping, not the run.

package/src/migrate-nx.ts

@@ -3,7 +3,8 @@
 
 import { stat } from 'node:fs/promises'
 import path from 'node:path'
-import { type MigrationFormat, type MigrationPlan, type ProjectMeta } from '@vzn/vx'
+import { type GeneratedProject, type MigrationFormat, type MigrationPlan } from '@vzn/vx'
+import type { PackageMeta } from './packages.js'
 import { mapNxWorkspace, nxSizeText, parseNxGraph, readNxJson } from './nx/nx-map.js'
 import { spareTrackedOutputs, trackedFiles, trackedKinds } from './tracked-outputs.js'
 import { adoptedToolNotes } from './workspace-notes.js'
@@ -17,11 +18,13 @@ export const NX_GRAPH_REL = '.nx/workspace-data/project-graph.json'
 /** `snapshot`: the graph file to read, absolute; the checked-in one by default. */
 export async function migrateNx(
   root: string,
-  metas: readonly ProjectMeta[],
+  metas: readonly PackageMeta[],
   format: MigrationFormat = 'ts',
   snapshot = path.join(root, NX_GRAPH_REL),
-  /** This run writes `vx.workspace.ts`, with nx.json's run settings as fields. */
+  /** This run writes `.vx/workspace.ts`, with nx.json's run settings as fields. */
   writesWorkspace = false,
+  /** No package.json anywhere: each config names its project and holds every edge. */
+  bare = false,
 ): Promise<MigrationPlan> {
   const graph = parseNxGraph(await Bun.file(snapshot).text(), path.relative(root, snapshot))
   const tracked = await trackedFiles(root)
@@ -33,9 +36,8 @@ export async function migrateNx(
     manifestField: (key) => ({ raw: `pkg.${key}` }),
     migration: true,
   })
-  // nx() takes each committed file under an output back every run; a
-  // written config must carry the same `!` entries, or its first run's
-  // clean deletes them.
+  // A reader whose `!` hides a committed file under another task's output
+  // runs uncached, as under nx().
   if (tracked !== null)
     for (const [id, todo] of spareTrackedOutputs(root, mapped.projects, tracked)) {
       const at = id.lastIndexOf('#')
@@ -48,14 +50,20 @@ export async function migrateNx(
     runner: 'nx',
     keys: (lock) => `Nx keys each project on the npm packages it depends on in ${lock}`,
   })
-  const unlisted = await unlistedProjects(root, metas, mapped.projects)
+  const unlisted = bare
+    ? { manifests: [], notes: bareNotes(mapped.projects) }
+    : await unlistedProjects(root, metas, mapped.projects)
+  if (bare) for (const p of mapped.projects) explicitOnly(p)
   return {
     headerNotes: [
-      'migrating from the resolved project-graph snapshot — plugin-inferred targets ' +
-        'are frozen as static config; `nx:run-commands` targets are their shell lines, and ' +
-        'every other executor runs as itself through `nx-exec` (keep Nx and @vzn/vx-migrate ' +
-        'installed until those targets are rewritten as commands); targets with `.env` files ' +
-        'run through `nx-env`',
+      bare
+        ? 'migrating from the resolved project-graph snapshot — plugin-inferred targets ' +
+          'are frozen as static config; `nx:run-commands` targets are their shell lines'
+        : 'migrating from the resolved project-graph snapshot — plugin-inferred targets ' +
+          'are frozen as static config; `nx:run-commands` targets are their shell lines, and ' +
+          'every other executor runs as itself through `nx-exec` (keep Nx and @vzn/vx-migrate ' +
+          'installed until those targets are rewritten as commands); targets with `.env` files ' +
+          'run through `nx-env`',
       ...adopted,
     ],
     projects: mapped.projects.map((p) =>
@@ -74,6 +82,38 @@ export async function migrateNx(
   }
 }
 
+/**
+ * A project with no manifest is named by its path unless its config names
+ * it, and a `^` edge follows the lockfile plugin's package edges, which a
+ * repo with no package.json has none of: the config keeps Nx's name, and
+ * the explicit edges the mapper drew from Nx's graph are every edge.
+ */
+function explicitOnly(p: GeneratedProject): void {
+  p.writeName = true
+  for (const t of p.tasks) {
+    const deps = t.task?.['dependsOn']
+    if (!Array.isArray(deps)) continue
+    const kept = deps.filter((d) => typeof d !== 'string' || !d.startsWith('^'))
+    // A group keeps its list, as `dropUnheldDeps` keeps one.
+    if (kept.length > 0 || t.task!['exec'] === undefined) t.task!['dependsOn'] = kept
+    else delete t.task!['dependsOn']
+  }
+}
+
+/** `nx-exec` and `nx-env` are this package's bins, and a repo with no package.json cannot install it. */
+function bareNotes(projects: readonly GeneratedProject[]): string[] {
+  const ids = projects.flatMap((p) =>
+    p.tasks.flatMap((t) => {
+      const cmd = (t.task?.['exec'] as { command?: unknown } | undefined)?.command
+      return typeof cmd === 'string' && /^nx-(exec|env) /.test(cmd) ? [`${p.name}#${t.name}`] : []
+    }),
+  )
+  if (ids.length === 0) return []
+  return [
+    `${ids.join(', ')} run${ids.length === 1 ? 's' : ''} through nx-exec or nx-env, @vzn/vx-migrate's bins, which a repo with no package.json cannot install: rewrite ${ids.length === 1 ? 'it' : 'them'} as commands`,
+  ]
+}
+
 /**
  * Nx projects no workspace glob lists (an integrated repo's `project.json`
  * libraries): core finds a project only by a listed package.json, so a
@@ -83,7 +123,7 @@ export async function migrateNx(
  */
 async function unlistedProjects(
   root: string,
-  metas: readonly ProjectMeta[],
+  metas: readonly PackageMeta[],
   projects: readonly { name: string; dir: string }[],
 ): Promise<{ manifests: { relPath: string; contents: string }[]; notes: string[] }> {
   const listed = new Set(metas.map((m) => path.resolve(m.dir)))
@@ -122,9 +162,10 @@ async function unlistedProjects(
   }
 }
 
-/** A `vx.workspace.ts` field nx.json's run settings call for. */
+/** A `.vx/workspace.ts` field nx.json's run settings call for. */
 export interface NxWorkspaceField {
-  readonly field: 'concurrency' | 'affectedBase' | 'cacheRetention'
+  /** The setting's path: its group, then its field. */
+  readonly field: 'run.concurrency' | 'run.affectedBase' | 'cache.retention'
   /** The value as TypeScript source; undefined when vx cannot read it. */
   readonly source: string | undefined
   /** What to tell a user whose workspace file this run does not write. */
@@ -135,7 +176,7 @@ const quoted = (s: string) => `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}
 
 /**
  * nx.json's run-wide settings `nx()` applies live: each a field of the
- * written `vx.workspace.ts`, or a migrated repo that ran one task at a time
+ * written `.vx/workspace.ts`, or a migrated repo that ran one task at a time
  * for a shared database ran on every core. nx.json only: the files are
  * written for every machine, so `NX_PARALLEL` and friends are not read.
  */
@@ -153,23 +194,23 @@ export function nxWorkspaceFields(json: Record<string, unknown> | undefined): Nx
   const parallel = nx?.parallel ?? nx?.tasksRunnerOptions?.default?.options?.parallel
   if (typeof parallel === 'number' && Number.isInteger(parallel) && parallel > 0)
     out.push({
-      field: 'concurrency',
+      field: 'run.concurrency',
       source: String(parallel),
-      note: `nx.json \`parallel: ${parallel}\`: add \`concurrency: ${parallel}\` to vx.workspace.ts`,
+      note: `nx.json \`parallel: ${parallel}\`: add \`run: { concurrency: ${parallel} }\` to .vx/workspace.ts`,
     })
   const base = nx?.defaultBase ?? nx?.affected?.defaultBase
   if (typeof base === 'string' && base.trim() !== '')
     out.push({
-      field: 'affectedBase',
+      field: 'run.affectedBase',
       source: quoted(base.trim()),
-      note: `nx.json \`defaultBase\` ${JSON.stringify(base.trim())}: add \`affectedBase: ${JSON.stringify(base.trim())}\` to vx.workspace.ts`,
+      note: `nx.json \`defaultBase\` ${JSON.stringify(base.trim())}: add \`run: { affectedBase: ${JSON.stringify(base.trim())} }\` to .vx/workspace.ts`,
     })
   const size = nxSizeText(nx?.maxCacheSize)
   if (size !== undefined)
     out.push({
-      field: 'cacheRetention',
+      field: 'cache.retention',
       source: /^\d+[KMG]?B$/.test(size) ? `{ maxSize: ${quoted(size)} }` : undefined,
-      note: `nx.json \`maxCacheSize\`: add \`cacheRetention: { maxSize: ${JSON.stringify(size)} }\` to vx.workspace.ts`,
+      note: `nx.json \`maxCacheSize\`: add \`cache: { retention: { maxSize: ${JSON.stringify(size)} } }\` to .vx/workspace.ts`,
     })
   return out
 }