@vzn/vx-migrate 0.0.635 → 0.0.637

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@vzn/vx-migrate",
-  "version": "0.0.635",
+  "version": "0.0.637",
   "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.635"
+    "@vzn/vx": "^0.0.637"
   },
   "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,10 +164,11 @@ 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`
       : '',
+    ' (what the written files import)',
   )
 }
 
@@ -204,13 +205,26 @@ async function runManager(
   argv: string[],
   what: string,
   ranHint = '',
+  why = '',
 ): 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
+  process.stdout.write(`vx-migrate: ${line}${why}\n`)
+  // 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 +234,13 @@ async function runManager(
       code = await spawn(launcher)
     } catch (e2) {
       code = -1
-      why = `: ${(e2 as Error).message}`
+      failed = `: ${(e2 as Error).message}`
     }
   }
   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/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)

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 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,10 +18,10 @@ 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,
 ): Promise<MigrationPlan> {
   const graph = parseNxGraph(await Bun.file(snapshot).text(), path.relative(root, snapshot))
@@ -33,9 +34,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('#')
@@ -83,7 +83,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 +122,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 +136,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 +154,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
 }