@vzn/vx-migrate 0.0.626 → 0.0.628

package/README.md

@@ -219,8 +219,8 @@ 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.
-- With no `vx.workspace.*` yet, it writes one declaring the plugins the repo calls for (`src/workspace-plugins.ts`): the `@vzn/vx-lockfile` factory for the lockfile (`pnpm()`, `bun()`, `npm()`, `yarn()`), `scheduleHistoryPlugin()`, and `github()` when `.github/workflows` exists, from `@vzn/vx-ci`, each installed beside `@vzn/vx` at vx-migrate's own version. Keep adds them to the file `vx init` writes, or to one already in that shape; any other workspace file is the user's and left alone.
-- It installs what the written files import with the repo's own manager (`packageManager`, else the lockfile): `@vzn/vx`, the declared plugins' packages, and `@vzn/vx-migrate` for keep or when a written task runs its `nx-exec` or `nx-env` bin (`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 the root both lists and has installed at vx-migrate's own version is left alone; any other is installed at that version. `--no-install` skips it.
+- With no `vx.workspace.*` yet, it writes one declaring the plugins the repo calls for (`src/workspace-plugins.ts`): the `@vzn/vx-lockfile` factory for the lockfile (`pnpm()`, `bun()`, `npm()`, `yarn()`), `scheduleHistoryPlugin()`, and `github()` when `.github/workflows` exists, from `@vzn/vx-ci`, each installed beside `@vzn/vx` at vx-migrate's own version. Keep adds them to the file `vx init` writes, or to one already in that shape; any other workspace file is the user's and left alone. Native over a file vx wrote (a keep adoption's) rewrites it: `turbo()` and `nx()` go, since the configs written replace them, and the other plugins stay.
+- It installs what the written files import with the repo's own manager (`packageManager`, else the lockfile): `@vzn/vx`, the declared plugins' packages, and `@vzn/vx-migrate` for keep or when a written task runs its `nx-exec` or `nx-env` bin (`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 the root both lists and has installed at vx-migrate's own version is left alone; any other is installed at that version. Native removes a listed `@vzn/vx-migrate` when nothing written needs it (no `nx-exec` / `nx-env` task, no `turboCache()` or `nxCache()` left in the workspace file): `pnpm remove -w`, `yarn remove` (`-W` on Yarn 1), `bun remove`, `npm uninstall`. `--no-install` skips both.
 
 A Lerna repo is an Nx one: Lerna 6+ runs `lerna run` on Nx's task runner over the graph `nx graph` exports, nx.json or not, so a `lerna.json` with no nx.json and no turbo.json is mapped from that graph, and keep writes the workspace file declaring `nx()` (`vx init` adopts by nx.json, and would map the scripts). Lerna is the installed one, else the root manifest's range; with neither, the lerna.json is another tool's (lerna-lite reads it too, and runs no Nx). A root whose scripts never `lerna run` runs its tasks another way and publishes with Lerna (webdriverio: `run-s`, `pnpm -r`), so its scripts stay the source. Not where Lerna runs its own runner: `useNx: false`, or Lerna 5 without `useNx: true`; those are `vx init`'s scripts mapping. Beside turbo.json, Turbo runs the tasks and Lerna only publishes: turbo.json is the source.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-migrate",
-  "version": "0.0.626",
+  "version": "0.0.628",
   "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.626"
+    "@vzn/vx": "^0.0.628"
   },
   "repository": {
     "type": "git",

package/src/adopt.ts

@@ -111,14 +111,9 @@ export function missingPackages(
   wanted: readonly string[],
   version: string | null = null,
 ): 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 listed = new Set(listedPackages(root, wanted))
   return wanted.filter((p) => {
-    if (!listed(p)) return true
+    if (!listed.has(p)) return true
     const installed = readText(path.join(root, 'node_modules', p, 'package.json'))
     if (installed === '') return true
     if (version === null) return false
@@ -126,17 +121,64 @@ export function missingPackages(
   })
 }
 
+/** argv that removes `packages` from the root's dev dependencies. */
+export function removeArgv(
+  root: string,
+  pm: PackageManager,
+  packages: readonly string[],
+): string[] {
+  switch (pm) {
+    case 'pnpm':
+      return ['pnpm', 'remove', '-w', ...packages]
+    case 'yarn':
+      return readText(path.join(root, 'yarn.lock')).includes('__metadata:')
+        ? ['yarn', 'remove', ...packages]
+        : ['yarn', 'remove', '-W', ...packages]
+    case 'bun':
+      return ['bun', 'remove', ...packages]
+    case 'npm':
+      return ['npm', 'uninstall', ...packages]
+  }
+}
+
+/** The `packages` the root package.json lists. */
+export function listedPackages(root: string, packages: readonly string[]): string[] {
+  const pj = JSON.parse(readText(path.join(root, 'package.json')) || '{}') as Record<
+    string,
+    Record<string, unknown> | undefined
+  >
+  return packages.filter((p) =>
+    ['dependencies', 'devDependencies'].some((f) => pj[f]?.[p] !== undefined),
+  )
+}
+
 /** Install `packages` (at `version`, given one) with the repo's manager, its output on the terminal. */
-export async function install(
+export function install(
   root: string,
   packages: readonly string[],
   version: string | null = null,
 ): Promise<string> {
-  const argv = installArgv(
+  return runManager(
     root,
-    packageManagerOf(root, process.env['npm_config_user_agent']),
-    version === null ? packages : packages.map((p) => `${p}@${version}`),
+    installArgv(
+      root,
+      packageManagerOf(root, process.env['npm_config_user_agent']),
+      version === null ? packages : packages.map((p) => `${p}@${version}`),
+    ),
+    'installing vx',
   )
+}
+
+/** Remove `packages` with the repo's manager. */
+export function uninstall(root: string, packages: readonly string[]): Promise<string> {
+  return runManager(
+    root,
+    removeArgv(root, packageManagerOf(root, process.env['npm_config_user_agent']), packages),
+    `removing ${packages.join(' ')}`,
+  )
+}
+
+async function runManager(root: string, argv: string[], what: string): Promise<string> {
   const line = argv.join(' ')
   process.stdout.write(`vx-migrate: ${line}\n`)
   let code: number
@@ -146,9 +188,7 @@ export async function install(
     code = -1
   }
   if (code !== 0) {
-    throw new UserError(
-      `installing vx failed (${line} exited ${code}); run it, then vx-migrate again`,
-    )
+    throw new UserError(`${what} failed (${line} exited ${code}); run it, then vx-migrate again`)
   }
   return line
 }

package/src/migrate.ts

@@ -31,17 +31,20 @@ import { readNxJson } from './nx/nx-map.js'
 import {
   type AdoptionMode,
   install,
+  listedPackages,
   missingPackages,
   MODE_QUESTION,
   ownVersion,
   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 {
   extendWorkspaceFile,
+  generatedPlugins,
   undeclared,
   renderWorkspaceFile,
   workspaceFileAt,
@@ -182,9 +185,20 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
   if (mode === 'keep' && runner !== 'vite-task') return keep(root, runner, hasTurbo, lerna, parsed)
 
   const format: MigrationFormat = parsed.mjs ? 'mjs' : 'ts'
-  // No workspace file yet: this run writes one, declaring the plugins the
-  // repo calls for and the run settings nx.json holds.
-  const writesWorkspace = workspaceFileAt(root) === undefined
+  // No workspace file yet, or one vx wrote (a `--keep` adoption's): this run
+  // writes it, declaring the plugins the repo calls for and the run settings
+  // nx.json holds. turbo() and nx() go: the configs written here replace them.
+  const existingWorkspace = workspaceFileAt(root)
+  const existingFormat = /\.(ts|mjs)$/.exec(existingWorkspace ?? '')?.[1] as
+    | MigrationFormat
+    | undefined
+  const adopted =
+    existingWorkspace === undefined
+      ? []
+      : existingFormat === undefined
+        ? null
+        : generatedPlugins(readFileSync(path.join(root, existingWorkspace), 'utf8'))
+  const writesWorkspace = adopted !== null
   let source: string
   let plan: MigrationPlan
   if (runner === 'vite-task') {
@@ -238,8 +252,11 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
           existsSync(path.join(p.dir, configName))),
     ) ||
       plan.extraFiles.some((f) => existsSync(path.join(root, f.relPath))))
-  // Drop the note that told the user to declare the lockfile plugin.
-  const plugins = writesWorkspace ? workspacePlugins(root) : []
+  const kept = (adopted ?? []).filter((p) => !ADOPTION_PLUGINS.has(`${p.pkg}#${p.factory}`))
+  const plugins = writesWorkspace
+    ? [...kept, ...workspacePlugins(root).filter((p) => !kept.some((k) => k.factory === p.factory))]
+    : []
+  let workspaceText: string | undefined
   if (writesWorkspace) {
     const fields =
       runner === 'nx'
@@ -247,16 +264,18 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
             f.source === undefined ? [] : [{ field: f.field, source: f.source }],
           )
         : []
+    workspaceText = renderWorkspaceFile(plugins, existingFormat ?? format, fields)
+    // Drop the notes that told the user to declare the lockfile plugin and
+    // to remove turbo() or nx().
     plan = {
       ...plan,
-      headerNotes: plan.headerNotes.filter((n) => !n.includes('from @vzn/vx-lockfile')),
-      extraFiles: [
-        ...plan.extraFiles,
-        {
-          relPath: `vx.workspace.${format}`,
-          contents: renderWorkspaceFile(plugins, format, fields),
-        },
-      ],
+      headerNotes: plan.headerNotes.filter(
+        (n) => !n.includes('from @vzn/vx-lockfile') && !n.includes(' still declares '),
+      ),
+      extraFiles:
+        existingWorkspace === undefined
+          ? [...plan.extraFiles, { relPath: `vx.workspace.${format}`, contents: workspaceText }]
+          : plan.extraFiles,
     }
   }
   // An executor target is an `nx-exec` line and a `.env` one an `nx-env`
@@ -267,13 +286,26 @@ export async function migrateCmd(args: readonly string[]): Promise<number> {
       return typeof cmd === 'string' && /^nx-(exec|env) /.test(cmd)
     }),
   )
+  // Nothing written imports vx-migrate or runs its bins: a `--keep`
+  // adoption's install of it is dropped with turbo() / nx().
+  const needsSelf =
+    runsBins ||
+    (workspaceText ?? readFileSync(path.join(root, existingWorkspace!), 'utf8')).includes(
+      "'@vzn/vx-migrate'",
+    )
   const headerNotes = refused
     ? []
-    : await prepareRepo(
-        root,
-        ['@vzn/vx', ...(runsBins ? ['@vzn/vx-migrate'] : []), ...plugins.map((p) => p.pkg)],
-        parsed,
-      )
+    : [
+        ...(existingWorkspace !== undefined && workspaceText !== undefined
+          ? await rewriteWorkspace(root, existingWorkspace, workspaceText, adopted!, parsed.dry)
+          : []),
+        ...(await prepareRepo(
+          root,
+          ['@vzn/vx', ...(needsSelf ? ['@vzn/vx-migrate'] : []), ...plugins.map((p) => p.pkg)],
+          parsed,
+          needsSelf ? [] : ['@vzn/vx-migrate'],
+        )),
+      ]
   return applyMigration({
     root,
     metas,
@@ -312,22 +344,52 @@ async function askMode(
   }
 }
 
+const ADOPTION_PLUGINS = new Set(['@vzn/vx-migrate#turbo', '@vzn/vx-migrate#nx'])
+
 /**
- * Install what the written files import. Returns the report's line;
- * installs nothing under `--dry`.
+ * A `--keep` adoption's workspace file, written over for a native one.
+ * Returns the report's line; writes nothing under `--dry`.
+ */
+async function rewriteWorkspace(
+  root: string,
+  file: string,
+  text: string,
+  before: readonly WorkspacePlugin[],
+  dry: boolean,
+): Promise<string[]> {
+  if (readFileSync(path.join(root, file), 'utf8') === text) return []
+  const dropped = before.filter((p) => ADOPTION_PLUGINS.has(`${p.pkg}#${p.factory}`))
+  const names = dropped.map((p) => `${p.factory}()`).join(', ')
+  if (dry)
+    return [`would ${dropped.length > 0 ? `drop ${names} from` : 'rewrite'} ${file} (dry run)`]
+  await Bun.write(path.join(root, file), text)
+  return [`${dropped.length > 0 ? `dropped ${names} from` : 'rewrote'} ${file}`]
+}
+
+/**
+ * Install what the written files import and remove what they no longer
+ * do. Returns the report's lines; changes nothing under `--dry`.
  */
 async function prepareRepo(
   root: string,
   wanted: readonly string[],
   args: MigrateArgs,
+  unwanted: readonly string[] = [],
 ): Promise<string[]> {
+  if (args.noInstall === true) return []
   const notes: string[] = []
   const version = ownVersion()
-  const missing = args.noInstall === true ? [] : missingPackages(root, wanted, version)
+  const missing = missingPackages(root, wanted, version)
   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, version)})`)
   }
+  // Last: the package removed may be the one running this.
+  const listed = listedPackages(root, unwanted)
+  if (listed.length > 0) {
+    if (args.dry) notes.push(`would remove ${listed.join(' ')} (dry run)`)
+    else notes.push(`removed ${listed.join(' ')} (${await uninstall(root, listed)})`)
+  }
   return notes
 }
 

package/src/workspace-plugins.ts

@@ -89,3 +89,32 @@ export function extendWorkspaceFile(
     `}${tail}`,
   ].join('\n')
 }
+
+/**
+ * The plugins of a workspace file vx wrote (`vx init`, `--keep`, a native
+ * migration): `@vzn` imports and argument-less calls, nothing else. Null
+ * for any other file, which is the user's and left alone.
+ */
+export function generatedPlugins(text: string): WorkspacePlugin[] | null {
+  const pkgOf = new Map<string, string>()
+  const body: string[] = []
+  for (const line of text.split('\n')) {
+    const m = /^import \{ ([\w, ]+) \} from '(@vzn\/[\w./-]+)'$/.exec(line)
+    if (m !== null) for (const name of m[1]!.split(',')) pkgOf.set(name.trim(), m[2]!)
+    else if (line !== "import type { WorkspaceConfig } from '@vzn/vx/config'") body.push(line)
+  }
+  const m =
+    /^export default \{\s*plugins:\s*\[((?:\s*\w+\(\)\s*,?)*)\s*\],?\s*\}(?: satisfies WorkspaceConfig)?$/.exec(
+      body.join('\n').trim(),
+    )
+  if (m === null) return null
+  const factories = [...m[1]!.matchAll(/(\w+)\(\)/g)].map((c) => c[1]!)
+  // No plugin at all is a file vx never wrote.
+  if (
+    factories.length === 0 ||
+    factories.length !== pkgOf.size ||
+    factories.some((f) => !pkgOf.has(f))
+  )
+    return null
+  return factories.map((factory) => ({ pkg: pkgOf.get(factory)!, factory }))
+}