@vzn/vx-migrate 0.0.508 → 0.0.510

package/README.md

@@ -56,7 +56,7 @@ Rules:
 - **The command is the script body** with its `pre<name>` / `post<name>` hooks folded in, in that order, through core's `foldScriptHooks`: each part in its own subshell, the chain stopping at the first that fails, forwarded `--` args reaching the body alone (npm and pnpm run them around `<name>` without being asked; novu's `prebuild` copies the CSS its `build` inlines), one process less per task than `pnpm run <name>` — except a body that calls yarn's `run` builtin (`run -T rollup -c`, `run clean && run build`; yarn ≥ 2 runs scripts in its own shell), which is `run: command not found` in sh: it runs as `yarn run <name>`, as Turbo and Nx run it, and yarn ≥ 2 runs no hooks, so none are folded there. A Yarn Plug'n'Play workspace (`.yarnrc.yml` with no `nodeLinker`, or `pnp`) has no `node_modules`: a dependency resolves only through `.pnp.cjs` and a bin only through yarn's shims, so there every script runs as `yarn run <name>`, and a `nodeLinker` change maps afresh. Same rules for `nx:run-script` below (strapi and novu, 2026-09-11).
 - **Turbo 2.11's task `command`** (`futureFlags.experimentalTaskCommand`) wins over the script, as Turbo holds it: an argv is the command — each word quoted, run from the package dir, no `pre`/`post` hooks — and gives the package the task even with no script (turborepo's `@turbo/types#build`, `docs#schema`); `null` or `[]` is Turbo's no-op node, no task even where the script exists, its edges passed through; a per-toolchain map applies its `javascript` entry (or `typescript`, Turbo's alias), and without one the script runs. A shape Turbo would refuse keeps the script, with a todo.
 - `dependsOn`: `^x` passes through when some package runs `x`, and is dropped when none does (Turbo gives it no edges; core refuses a `^x` no project declares as a typo); `pkg#task` is kept only when `pkg` emits `task` (else a todo: edge dropped); a same-package task Turbo defines but the package has no script for is Turbo's no-op node, so its own edges pass through in its place (`test → codegen → ^build` with no `codegen` script is `test → ^build`); another package's `^x` or `pkg#x` reaches such a node through a group task when its edges name a task of its own package or another (with-tailwind's `ui` has no `build` script; its `build` builds `build:styles` and `build:components`, and `web#build` waits on them), and so does one whose `^` edge names another task (rallly's script-less `build` holds `^db:generate`), while one whose only edge is `^` to its own name needs none, since core's `^x` walks past a package without `x`; a no-op node nothing else reaches runs nothing, its own edges included, where Turbo still runs them (kitchen-sink's `turbo run test` builds `@repo/ui` for `admin`, which has no `test` script; `vx run test --all` does not, and `vx run build test --all` does both); a name Turbo does not define has no edge; `$TURBO_ROOT$` deps are a todo. Root `//#task`s run in the workspace root, as under Turbo: `turbo()` names the root a project through core's `discover` stage when turbo.json declares one (no `vx.config` needed; a root no member glob lists), and `//#x` in `dependsOn` is an edge to it, named by the root `package.json` `name`; a root task's globs are the workspace's (`workspaceFiles`), since Turbo hashes a root task over the whole repo; with no root project (a root `package.json` with no `name`, or one a package holds) they are a note and such an edge a todo. Turbo runs no plain task in the root package of a monorepo, and neither does `turbo()`; in a single-package repo (no workspaces, Turbo's `non-monorepo` example) turbo.json's plain tasks run on the root package, as under Turbo.
-- A transit node (Turbo's documented pattern, its with-vitest example: `transit: { dependsOn: ["^transit"] }` with no script anywhere, and `test: { dependsOn: ["transit"] }`) is a key-only task in each package that defines it: it runs `true`, cached and keyed on its inputs, with its `^transit` edge, so a dependant's `test` re-keys on its dependencies' sources as Turbo re-hashes it. A `^` task that some package has a script for, or that nothing depends on, is no transit node. A package without the script of a `^` task others run gets the same key-only task, as Turbo hashes a no-op node there: an edit to it re-keys its dependants.
+- A transit node (Turbo's documented pattern, its with-vitest example: `transit: { dependsOn: ["^transit"] }` with no script anywhere, and `test: { dependsOn: ["transit"] }`) is a key-only task in each package that defines it: it runs `true`, cached and keyed on its inputs, with its `^transit` edge, so a dependant's `test` re-keys on its dependencies' sources as Turbo re-hashes it. A `^` task that some package has a script for, or that nothing depends on, is no transit node. A package without the script of a `^` task others run gets the same key-only task, as Turbo hashes a no-op node there: an edit to it re-keys its dependants. A `build` whose only edge is `^build` is not written: core gives every project with no `build` that node (solid's three script-less packages each got a `build` running `true`).
 - `with` (tasks Turbo runs alongside, `web#dev` with `api#dev`): an edge to each sidecar that is persistent, so vx starts the task once the sidecar has spawned and runs the sidecar only when the task runs; a sidecar that ends would be waited for, so it is a todo instead, and a pair that names each other keeps one edge (two would be a cycle). A task with no script whose `with` names persistent sidecars (Turbo's with-tailwind example: `ui` has no `dev` script, its `dev` starts `dev:styles` and `dev:components`) is a group task that depends on them.
 - `inputs`: a structured entry (Turbo 2.11) is its `globs`, plus `**/*` with `withDefaults`, for `startup` and `jit` alike; `dependencyOutputs` adds none (vx folds each dependency's key). Then: absent or `[]` → `**/*` (Turbo's default); `$TURBO_DEFAULT$` → `**/*`; exclusions alone narrow `**/*`; `$TURBO_ROOT$/<path>` → `cache.inputs.workspaceFiles` (negation kept); any other `$TURBO_ROOT$` use is a todo. `globalDependencies` and Turbo 1's `globalDotEnv` land in `workspaceFiles` too, and a task's Turbo 1 `dotEnv` in its `files`. Turbo 1's `$NAME` entries, in `globalDependencies` or a task's `dependsOn`, are env vars: they join `cache.inputs.env` and `exec.env.passThrough`. A package nested in the task's package (cal.com's apps inside `@calcom/app-store`) is hashed by Turbo with its parent, and core's globs stop at a project: each glob that reaches one is also listed in `cache.inputs.workspaceFiles`. Turbo's glob grammar is translated as Nx's is (`*.[jt]s` is `*.{[jt],j,t}s`); an input with no safe form widens to `**/*` with a todo. A `.env`-shaped input (`.env*`, `.env.local`, a task's Turbo 1 `dotEnv`, create-turbo's `globalDependencies: ["**/.env.*local"]`) is gitignored as a rule, so it is keyed by a probe that hashes the `.env` files it can name (`cache.inputs.runtime`) or, for a root entry, the files its root-relative globs name, hidden ones too, as Turbo's `*` matches them (`workspaceRuntime`; `**/<name>` is a `find -name` that skips `node_modules`, and another `**` walks the workspace), rather than as a file glob git never reports. A package whose `.env` globs all sit at its root gets a one-shell probe of that directory; one below the root walks the package.
 - `outputs`: `$TURBO_ROOT$/<path>` → `cache.outputs.workspaceFiles`; a negated output rides beside its positives and takes its paths back from the clean, the save and the restore (Next's `.next/**` minus `!.next/cache/**` keeps the cache), and one with no positive beside it takes back nothing and is dropped. Past its first segment an output takes Turbo's grammar (`dist/**/*.[cm]js`); the first stays a literal (a route directory). An output whose first segment is a wildcard (`**/*.d.ts`, `*/**`) runs the task uncached with a todo: Turbo never cleans an output, vx cleans it before every run, and such a glob reaches the sources. One segment with a literal extension the package tracks no file of (`*.xml`, `*.tsbuildinfo`) reaches only top-level artifacts and stays cached, and so does `**/<dir>/**` when the package tracks nothing under a directory of that name (vercel/ai's `**/dist/**`; `node_modules` is never an output), and so does a first segment no tracked top-level entry matches (tldraw's `dist-*/**`). A wildcard first segment with a literal rest (clerk's `*/package.json`, the subpath stubs it commits) reaches only files of that name: each committed one, up to 16, is taken back with `!` and the task stays cached; more, and it runs uncached. An output that covers the package's own `package.json` (trpc's client build lists it: the build rewrites `exports`) runs the task uncached with a todo: vx would delete the manifest before every run, and core refuses that config. `nx()` takes the manifest back with `!package.json` instead and keeps the cache (owner, 2026-10-03). So does one that covers the package's vx.config; `turbo()` and `nx()` check the config the package has, and `vx-migrate` the one it writes, so sanity's `*.js` shims stay cached beside none. `nx()` keeps a wildcard-first output cached instead: each committed file it reaches is taken back with `!` (past sixteen, uncached with a todo), and the clean removes the rest, what the task writes (owner, 2026-10-03). A committed file under an output (typescript-eslint's `data/sponsors.json` in a cached `data`) is taken back with `!` — Turbo and Nx never clean an output, vx does — so it survives the clean and the task keeps its cache; past sixteen such files the task runs uncached with a todo. `turbo()` and `nx()` both do this, and so do the configs `vx-migrate` writes from turbo.json or an Nx graph (each take-back is a todo there, as it names files a later commit may move).
@@ -204,9 +204,19 @@ bunx @vzn/vx-migrate           # auto-detect: turbo.json, .nx/workspace-data/pro
 bunx @vzn/vx-migrate --dry     # print the generated files + the report instead of writing
 bunx @vzn/vx-migrate --force   # overwrite existing vx.config.* / vx-preset.ts
 bunx @vzn/vx-migrate --from nx # disambiguate when both runners are checked in
+bunx @vzn/vx-migrate --native  # write vx.config.ts files without asking
+bunx @vzn/vx-migrate --keep    # keep turbo.json / nx.json as the source: turbo() or nx(), as `vx init` writes it
 bunx @vzn/vx-migrate --help    # the usage, exit 0
 ```
 
+It is the one command a repo needs (`pnpx @vzn/vx-migrate` in a pnpm repo works the same):
+
+- In a terminal it asks which adoption you want: **native** (the default, a `vx.config.ts` per package) or **keep** (the workspace file `vx init` writes, declaring `turbo()` or `nx()`). `--native` / `--keep` answer it; with no terminal (CI, a pipe) it is native.
+- It installs what the written files import with the repo's own manager (`packageManager`, else the lockfile): `@vzn/vx`, plus `@vzn/vx-migrate` for keep (`pnpm add -D -w`, `yarn add -D -W` on Yarn 1 and without `-W` on Yarn 2+, `bun add -d`, `npm install -D`). A package already listed or installed is left alone; `--no-install` skips it.
+- A root `package.json` script that is only `turbo run <tasks>` or `nx run-many -t <tasks>` becomes `vx run <tasks> --all`, so `pnpm run build` runs vx. A script with flags or a chain is left as it is.
+
+`--dry` does none of the three, and says what it would install and change.
+
 `--dry` prints the files instead of writing them; `--force` overwrites existing ones; `--mjs` writes `vx.config.mjs` (and `vx-preset.mjs`) instead of `.ts` — the same objects with no type import and no `satisfies`, for a package whose own `tsconfig` includes every `.ts` under it and would compile the config into its dist (TanStack/query, 2026-09-11).
 
 `package.json` scripts are core's own `vx init`. What this package writes reads exactly like what `vx init` writes: both hand a plan to core's migration seam (`applyMigration` from `@vzn/vx`), which renders, refuses to overwrite without `--force`, writes and reports. Anything a source cannot say becomes a `TODO(vx-migrate)` comment, never a silent wrong value.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-migrate",
-  "version": "0.0.508",
+  "version": "0.0.510",
   "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",
   "keywords": [
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@vzn/vx": "^0.0.508"
+    "@vzn/vx": "^0.0.510"
   },
   "repository": {
     "type": "git",

package/src/adopt.ts

@@ -0,0 +1,176 @@
+// What `vx-migrate` does around the mapping so the repo runs vx after it:
+// which kind of adoption (native configs, or the runner's config read live),
+// installing vx with the repo's own package manager, and pointing the root
+// scripts that called the runner at vx (solidjs/solid, 2026-10-04: the
+// configs were written, and `pnpm run build` still ran turbo, with no vx
+// installed to run them).
+
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { UserError } from '@vzn/vx'
+
+export type AdoptionMode = 'native' | 'keep'
+
+/** The question a TTY run asks; `null` (no answer, EOF) is the default. */
+export const MODE_QUESTION = (runner: 'turbo' | 'nx', source: string) =>
+  `${source} found. How should vx run this repo?\n` +
+  `  1) native: write a vx.config.ts per package from ${source} (recommended)\n` +
+  `  2) keep: keep ${source} as the source; vx reads it on every run through ${runner}()\n` +
+  'Choose 1 or 2 [1]:'
+
+/** `1`/`native` (or nothing) → native, `2`/`keep` → keep; anything else asks again. */
+export function parseModeAnswer(answer: string | null): AdoptionMode | undefined {
+  const a = (answer ?? '').trim().toLowerCase()
+  if (a === '' || a === '1' || a === 'native' || a === 'n') return 'native'
+  if (a === '2' || a === 'keep' || a === 'k') return 'keep'
+  return undefined
+}
+
+export type PackageManager = 'pnpm' | 'yarn' | 'bun' | 'npm'
+
+const LOCKFILES: ReadonlyArray<readonly [string, PackageManager]> = [
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['yarn.lock', 'yarn'],
+  ['bun.lock', 'bun'],
+  ['bun.lockb', 'bun'],
+  ['package-lock.json', 'npm'],
+]
+
+function readText(file: string): string {
+  try {
+    return readFileSync(file, 'utf8')
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * The repo's manager: package.json's `packageManager` (corepack's field),
+ * else the lockfile, else the one that started this process, else npm.
+ */
+export function packageManagerOf(root: string, userAgent?: string): PackageManager {
+  const field = (
+    JSON.parse(readText(path.join(root, 'package.json')) || '{}') as { packageManager?: unknown }
+  ).packageManager
+  const declared =
+    typeof field === 'string'
+      ? (/^(pnpm|yarn|bun|npm)@/.exec(field)?.[1] as PackageManager | undefined)
+      : undefined
+  if (declared !== undefined) return declared
+  const locked = LOCKFILES.find(([f]) => existsSync(path.join(root, f)))?.[1]
+  if (locked !== undefined) return locked
+  return (
+    (/^(pnpm|yarn|bun|npm)\//.exec(userAgent ?? '')?.[1] as PackageManager | undefined) ?? 'npm'
+  )
+}
+
+/** argv that adds `packages` as root dev dependencies. */
+export function installArgv(
+  root: string,
+  pm: PackageManager,
+  packages: readonly string[],
+): string[] {
+  switch (pm) {
+    case 'pnpm':
+      return ['pnpm', 'add', '-D', '-w', ...packages]
+    case 'yarn':
+      // Yarn 1 refuses `add` at a workspace root without `-W`; Berry has no
+      // such flag. A Berry lockfile carries `__metadata`.
+      return readText(path.join(root, 'yarn.lock')).includes('__metadata:')
+        ? ['yarn', 'add', '-D', ...packages]
+        : ['yarn', 'add', '-D', '-W', ...packages]
+    case 'bun':
+      return ['bun', 'add', '-d', ...packages]
+    case 'npm':
+      return ['npm', 'install', '-D', ...packages]
+  }
+}
+
+/** The packages a mode's files import that the root neither lists nor has installed. */
+export function missingPackages(root: string, mode: AdoptionMode): string[] {
+  const pj = JSON.parse(readText(path.join(root, 'package.json')) || '{}') as Record<
+    string,
+    Record<string, unknown> | undefined
+  >
+  const listed = (name: string) =>
+    ['dependencies', 'devDependencies'].some((f) => pj[f]?.[name] !== undefined)
+  const wanted = mode === 'keep' ? ['@vzn/vx', '@vzn/vx-migrate'] : ['@vzn/vx']
+  return wanted.filter(
+    (p) => !listed(p) && !existsSync(path.join(root, 'node_modules', p, 'package.json')),
+  )
+}
+
+/** Install `packages` with the repo's manager, its output on the terminal. */
+export async function install(root: string, packages: readonly string[]): Promise<string> {
+  const argv = installArgv(
+    root,
+    packageManagerOf(root, process.env['npm_config_user_agent']),
+    packages,
+  )
+  const line = argv.join(' ')
+  process.stdout.write(`vx-migrate: ${line}\n`)
+  let code: number
+  try {
+    code = await Bun.spawn(argv, { cwd: root, stdio: ['inherit', 'inherit', 'inherit'] }).exited
+  } catch {
+    code = -1
+  }
+  if (code !== 0) {
+    throw new UserError(
+      `installing vx failed (${line} exited ${code}); run it, then vx-migrate again`,
+    )
+  }
+  return line
+}
+
+/**
+ * A root script that is only `turbo run <tasks>`, or
+ * Nx's `nx run-many -t <tasks>`, as the same run under vx. Flags, a chain or
+ * anything else is left alone: only what reads the same both ways is moved.
+ */
+export function vxScript(command: string): string | undefined {
+  const words = command.trim().split(/\s+/)
+  let tasks: string[] | undefined
+  // `turbo <tasks>` is left: `turbo watch dev` is a verb, not a task.
+  if (words[0] === 'turbo' && words[1] === 'run') {
+    const rest = words.slice(2)
+    if (rest.length > 0 && rest.every((w) => /^[\w:.@/-]+$/.test(w) && !w.startsWith('-')))
+      tasks = rest
+  } else if (words[0] === 'nx' && words[1] === 'run-many') {
+    const rest = words.slice(2)
+    if (
+      (rest[0] === '-t' || rest[0] === '--target' || rest[0] === '--targets') &&
+      rest.length === 2
+    )
+      tasks = rest[1]!.split(',')
+    else if (rest.length === 1 && /^--targets?=/.test(rest[0]!))
+      tasks = rest[0]!.replace(/^--targets?=/, '').split(',')
+    if (tasks?.some((t) => !/^[\w:.@/-]+$/.test(t))) tasks = undefined
+  }
+  return tasks === undefined ? undefined : `vx run ${tasks.join(' ')} --all`
+}
+
+/**
+ * Point the root package.json scripts that call the runner at vx, editing
+ * the text in place (key order, indent and the rest kept). Returns each
+ * `name: old → new`; writes nothing under `dry`.
+ */
+export async function rewriteRootScripts(root: string, dry: boolean): Promise<string[]> {
+  const file = path.join(root, 'package.json')
+  let text = readText(file)
+  const scripts = (JSON.parse(text || '{}') as { scripts?: Record<string, unknown> }).scripts ?? {}
+  const changed: string[] = []
+  for (const [name, value] of Object.entries(scripts)) {
+    if (typeof value !== 'string') continue
+    const next = vxScript(value)
+    if (next === undefined) continue
+    const key = JSON.stringify(name).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const old = JSON.stringify(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const re = new RegExp(`(${key}\\s*:\\s*)${old}`)
+    if (!re.test(text)) continue
+    text = text.replace(re, (_, lead: string) => `${lead}${JSON.stringify(next)}`)
+    changed.push(`${name}: ${value} → ${next}`)
+  }
+  if (!dry && changed.length > 0) await Bun.write(file, text)
+  return changed
+}

package/src/migrate.ts

@@ -1,11 +1,15 @@
-// `vx-migrate [--from turbo|nx] [--dry] [--force] [--mjs]` — one
-// vx.config.ts per workspace package from an existing Turbo or Nx
-// setup. Source auto-detect: turbo.json → Turbo;
+// `vx-migrate [--from turbo|nx] [--native|--keep] [--no-install] [--dry]
+// [--force] [--mjs]` — one vx.config.ts per workspace package from an
+// existing Turbo or Nx setup (`--keep`: the workspace file that reads it
+// live instead, as `vx init` writes it), vx installed with the repo's
+// manager, and the root scripts that called the runner pointed at vx.
+// Without either mode flag a terminal is asked; anything else is native. Source auto-detect: turbo.json → Turbo;
 // .nx/workspace-data/project-graph.json or nx.json → Nx (the resolved graph, exported by nx if absent);
 // The mappers return a plan; core's migration seam
 // (`applyMigration`) renders, guards, writes and reports, so what this
 // package writes reads exactly like what `vx init` writes.
 
+import { existsSync, realpathSync } from 'node:fs'
 import { mkdtemp, rm } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
@@ -21,6 +25,14 @@ import {
 } from '@vzn/vx'
 import { migrateNx, NX_GRAPH_REL } from './migrate-nx.js'
 import { exportGraph } from './nx/export-graph.js'
+import {
+  type AdoptionMode,
+  install,
+  missingPackages,
+  MODE_QUESTION,
+  parseModeAnswer,
+  rewriteRootScripts,
+} from './adopt.js'
 import { migrateTurbo } from './migrate-turbo.js'
 import { turboConfigFile } from './turbo/turbo-map.js'
 
@@ -30,12 +42,17 @@ export interface MigrateArgs {
   /** `vx.config.mjs` (and `vx-preset.mjs`) instead of `.ts`. */
   mjs: boolean
   from?: 'turbo' | 'nx'
+  /** `--native` / `--keep`; unset asks a terminal and is native elsewhere. */
+  mode?: AdoptionMode
+  /** `--no-install`: leave package.json's dependencies alone. */
+  noInstall?: boolean
   /** `--help` / `-h`: the usage on stdout, exit 0 (as `nx-env --help`). */
   help?: boolean
   error?: string
 }
 
-const USAGE = 'usage: vx-migrate [--from turbo|nx] [--dry] [--force] [--mjs]'
+const USAGE =
+  'usage: vx-migrate [--from turbo|nx] [--native|--keep] [--no-install] [--dry] [--force] [--mjs]'
 
 export function parseMigrateArgs(args: readonly string[]): MigrateArgs {
   const out: MigrateArgs = { dry: false, force: false, mjs: false }
@@ -44,7 +61,14 @@ export function parseMigrateArgs(args: readonly string[]): MigrateArgs {
     if (a === '--dry') out.dry = true
     else if (a === '--force') out.force = true
     else if (a === '--mjs') out.mjs = true
-    else if (a === '--from' || a?.startsWith('--from=')) {
+    else if (a === '--no-install') out.noInstall = true
+    else if (a === '--native' || a === '--keep') {
+      const mode = a === '--native' ? 'native' : 'keep'
+      if (out.mode !== undefined && out.mode !== mode) {
+        return { ...out, error: '--native and --keep are two answers to one question; pass one' }
+      }
+      out.mode = mode
+    } else if (a === '--from' || a?.startsWith('--from=')) {
       const v = a === '--from' ? args[++i] : a.slice('--from='.length)
       if (v !== 'turbo' && v !== 'nx') {
         return {
@@ -116,14 +140,25 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
     throw new UserError('--from turbo, but no turbo.json at the workspace root')
   }
 
+  const runner: 'turbo' | 'nx' | undefined =
+    parsed.from ?? (hasTurbo ? 'turbo' : hasGraph || hasNxJson ? 'nx' : undefined)
+  if (runner === undefined) {
+    throw new UserError(
+      'nothing to migrate: no turbo.json and no Nx workspace — ' +
+        'for package.json scripts, run `vx init`',
+    )
+  }
+  const mode = parsed.mode ?? (await askMode(runner, parsed.dry))
+  if (mode === 'keep') return keep(root, runner, hasTurbo, parsed)
+
   const format: MigrationFormat = parsed.mjs ? 'mjs' : 'ts'
   let source: string
   let plan: MigrationPlan
-  if (parsed.from === 'nx' || (parsed.from === undefined && !hasTurbo)) {
+  if (runner === 'nx') {
     if (hasGraph) {
       source = NX_GRAPH_REL
       plan = await migrateNx(root, metas, format)
-    } else if (hasNxJson || parsed.from === 'nx') {
+    } else {
       // Modern Nx stores the graph in SQLite, so the JSON snapshot exists only
       // when exported. The workspace's own nx exports it, as `nx()` does, into
       // a temp file; the user ran that step by hand until 2026-10-01.
@@ -142,24 +177,99 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
       } finally {
         await rm(tmp, { recursive: true, force: true })
       }
-    } else {
-      throw new UserError(
-        'nothing to migrate: no turbo.json and no Nx workspace — ' +
-          'for package.json scripts, run `vx init`',
-      )
     }
   } else {
     source = path.basename(turboFile ?? 'turbo.json')
     plan = await migrateTurbo(root, metas, format)
   }
+  // Before the write, so the report's `next:` line runs the installed vx;
+  // not when the write will be refused for a config already there.
+  const configName = `vx.config.${format}`
+  const refused =
+    !parsed.force &&
+    (plan.projects.some(
+      (p) =>
+        p.tasks.length > 0 &&
+        (metas.some((m) => m.dir === p.dir && m.configPath) ||
+          existsSync(path.join(p.dir, configName))),
+    ) ||
+      plan.extraFiles.some((f) => existsSync(path.join(root, f.relPath))))
+  const headerNotes = refused ? [] : await prepareRepo(root, 'native', parsed)
   return applyMigration({
     root,
     metas,
     plan,
     source,
     verb: 'vx-migrate',
+    notes: headerNotes,
     dry: parsed.dry,
     force: parsed.force,
     format,
   })
 }
+
+/** A terminal is asked which adoption it wants; anything else gets native. */
+async function askMode(runner: 'turbo' | 'nx', dry: boolean): Promise<AdoptionMode> {
+  if (dry || !process.stdin.isTTY || !process.stdout.isTTY) return 'native'
+  const source = runner === 'turbo' ? 'turbo.json' : 'nx.json'
+  for (;;) {
+    const mode = parseModeAnswer(prompt(MODE_QUESTION(runner, source)))
+    if (mode !== undefined) return mode
+  }
+}
+
+/**
+ * Install what the written files import and point the root scripts at vx.
+ * Returns the report's lines for both; does neither under `--dry` (the
+ * script lines say what would change).
+ */
+async function prepareRepo(root: string, mode: AdoptionMode, args: MigrateArgs): Promise<string[]> {
+  const notes: string[] = []
+  const missing = args.noInstall === true ? [] : missingPackages(root, mode)
+  if (missing.length > 0) {
+    if (args.dry) notes.push(`would install ${missing.join(' ')} (dry run)`)
+    else notes.push(`installed ${missing.join(' ')} (${await install(root, missing)})`)
+  }
+  const scripts = await rewriteRootScripts(root, args.dry)
+  if (scripts.length > 0) {
+    notes.push(
+      `${args.dry ? 'would point' : 'pointed'} root package.json scripts at vx: ${scripts.join('; ')}`,
+    )
+  }
+  return notes
+}
+
+/**
+ * `--keep`: the workspace file `vx init` writes, declaring `turbo()` or
+ * `nx()`, so the runner's own config stays the source. `vx init` is the
+ * one writer of that file; this runs the installed one.
+ */
+async function keep(
+  root: string,
+  runner: 'turbo' | 'nx',
+  hasTurbo: boolean,
+  args: MigrateArgs,
+): Promise<number> {
+  // `vx init` reads turbo.json first.
+  if (runner === 'nx' && hasTurbo) {
+    throw new UserError(
+      '--keep with --from nx: turbo.json is here too, and vx init adopts it first',
+    )
+  }
+  for (const note of await prepareRepo(root, 'keep', args)) {
+    process.stdout.write(`vx-migrate: ${note}\n`)
+  }
+  // A resolve that misses from a directory with no node_modules is an
+  // auto-install under Bun: ask the root only where it has the package.
+  const installed = path.join(root, 'node_modules', '@vzn', 'vx')
+  const core = existsSync(path.join(installed, 'package.json'))
+    ? path.join(realpathSync(installed), 'src', 'index.ts')
+    : Bun.resolveSync('@vzn/vx', import.meta.dir)
+  const flags = [args.dry && '--dry', args.force && '--force', args.mjs && '--mjs'].filter(
+    (f): f is string => typeof f === 'string',
+  )
+  return Bun.spawn(
+    [process.execPath, '--no-install', path.join(path.dirname(core), 'bin.ts'), 'init', ...flags],
+    { cwd: root, stdio: ['inherit', 'inherit', 'inherit'] },
+  ).exited
+}

package/src/turbo/turbo-map.ts

@@ -1259,6 +1259,11 @@ export async function mapTurboWorkspace(
       if (override === null) continue
       const script = scripts[name]
       const noop = keyOnly.get(meta.name)?.has(name) === true
+      // Core gives a project with no `build` this very node (a group behind
+      // `^build`, keyed on the project's files), so writing it is noise:
+      // solid's three script-less packages each got a `build` running `true`.
+      if (noop && name === 'build' && (defFor(name)!.dependsOn ?? []).every((d) => d === '^build'))
+        continue
       if (
         override === undefined &&
         script === undefined &&