@vzn/vx 0.0.349 → 0.0.352

package/src/workspace/affected.ts

@@ -592,7 +592,8 @@ async function gitPaths(workspaceRoot: string, cmd: string[]): Promise<string[]>
 /**
  * Resolve the default base for `--affected` with no explicit value.
  * Tries the remote's HEAD branch first (`origin/main`, `origin/master`,
- * etc.), then falls back to `HEAD~1`. A clone with no `origin/HEAD` and
+ * etc.), then `origin/main`, `origin/master`, `main`, `master`, then
+ * falls back to `HEAD~1`. A clone with no `origin/HEAD` and
  * no parent commit — a CI checkout at `fetch-depth: 1` — has no base at
  * all, and says so here rather than failing on a ref nobody typed.
  */
@@ -609,6 +610,12 @@ export async function defaultAffectedBase(workspaceRoot: string): Promise<string
   if (probe.exitCode === 0 && out.length > 0 && revParse(workspaceRoot, out) !== undefined) {
     return out
   }
+  // No origin/HEAD: `git remote add` + fetch, as actions/checkout does, sets
+  // none, and `HEAD~1` saw only a feature branch's last commit where Turbo
+  // and Nx compare with `main` (D-93). The usual trunk names, remote first;
+  // one that IS HEAD (a push to main) falls through to `HEAD~1` as before.
+  const trunk = trunkBase(workspaceRoot)
+  if (trunk !== undefined) return trunk
   if (revParse(workspaceRoot, 'HEAD~1') === undefined) {
     throw new UserError(
       '--affected has no base here: origin/HEAD is not set (or names a branch that is gone) and HEAD has no parent to compare ' +
@@ -619,6 +626,32 @@ export async function defaultAffectedBase(workspaceRoot: string): Promise<string
   return 'HEAD~1'
 }
 
+const TRUNKS = ['origin/main', 'origin/master', 'main', 'master']
+
+/** The first of `TRUNKS` that exists and is not HEAD's commit, in one spawn. */
+function trunkBase(workspaceRoot: string): string | undefined {
+  const proc = spawnGitSync(
+    [
+      'for-each-ref',
+      '--format=%(refname:short) %(objectname)',
+      '--end-of-options',
+      ...TRUNKS.map((t) => (t.startsWith('origin/') ? `refs/remotes/${t}` : `refs/heads/${t}`)),
+    ],
+    workspaceRoot,
+    'ignore',
+  )
+  if (proc.exitCode !== 0) return undefined
+  const at = new Map(
+    new TextDecoder()
+      .decode(proc.stdout)
+      .split('\n')
+      .filter((l) => l !== '')
+      .map((l) => l.split(' ') as [string, string]),
+  )
+  const head = revParse(workspaceRoot, 'HEAD')
+  return TRUNKS.find((t) => at.has(t) && at.get(t) !== head)
+}
+
 /**
  * Does `ref` name the commit HEAD is on? A base that IS HEAD can never
  * mark anything affected — the shape of a single-branch clone whose

package/src/workspace/config-schema.ts

@@ -742,6 +742,16 @@ const FOREIGN_FIELDS: ReadonlyMap<ReadonlySet<string>, Readonly<Record<string, s
         '`exec.command`: vx runs one shell command (`nx()` from `@vzn/vx-migrate` runs an Nx executor as one)',
       options: '`exec.command` (a run-commands `options.command`) and `exec.env`',
       outputLogs: 'the `--output-logs` flag of `vx run`',
+      // Turbo's `interactive` / `with`, Nx's `cwd` / `parallelism` /
+      // `configurations`: refused with no word on where they went (D-89).
+      interactive:
+        'a command run outside vx: a task never reads the terminal (its stdin is EOF, or a pipe vx holds under `exec.persistent`)',
+      with: '`dependsOn` on each task it runs beside: a persistent one stays up, and this task starts once it is ready',
+      cwd: '`cd <dir> && …` in `exec.command`: a task runs in its project directory',
+      parallelism:
+        '`concurrency: 1` in vx.workspace or `--concurrency 1` on the run: no task runs alone beside others',
+      configurations:
+        'one task per configuration (`build:production`, with its own `exec.command`)',
     },
   ],
   [EXEC_FIELDS, { cmd: '`command`', script: '`command`' }],
@@ -755,6 +765,24 @@ const FOREIGN_FIELDS: ReadonlyMap<ReadonlySet<string>, Readonly<Record<string, s
       implicitDependencies: 'a `dependsOn` entry `pkg#task`, or a package.json dependency',
       name: 'the package.json `name` (a project is named by its package)',
       tags: '`--filter` (a name glob or a directory) to select projects',
+      // A package.json's, turbo.json's and project.json's keys, and a
+      // task's fields one level too high (D-99).
+      scripts:
+        "`tasks` (a script is a task's `exec.command`; `vx init` writes them from package.json)",
+      pipeline: '`tasks` (`bunx @vzn/vx-migrate` writes them from turbo.json)',
+      namedInputs: 'a module the vx.config imports, spread into `cache.inputs.files`',
+      root: "no field: a project's directory is where its package.json sits",
+      sourceRoot: "a task's `cache.inputs.files`",
+      projectType: 'no field: vx runs every project alike',
+      ...Object.fromEntries(
+        ['dependsOn', 'cache', 'exec', 'description'].map((k) => [
+          k,
+          `\`tasks.<name>.${k}\`: a project holds tasks, and each task its own \`${k}\``,
+        ]),
+      ),
+      inputs: '`tasks.<name>.cache.inputs.files`',
+      outputs: '`tasks.<name>.cache.outputs.files`',
+      env: '`tasks.<name>.cache.inputs.env` (to key a task on it) or `tasks.<name>.exec.env`',
     },
   ],
   // Turbo's turbo.json and Nx's nx.json keys, written into vx.workspace

package/src/workspace/migrate-scripts.ts

@@ -55,12 +55,14 @@ const LIFECYCLE = /^(pre|post)(install|publish|pack|version)$|^(prepare|prepubli
  */
 export function delegatedScript(command: string): string | null {
   const m =
-    /^(?:(?:npm run|(pnpm|yarn|bun)(?: (run))?) ([^\s&|;<>()$`'"\\]+)|npm (test|start))$/.exec(
+    /^(?:(?:npm run|(pnpm|pn|yarn|bun)(?: (run))?) ([^\s&|;<>()$`'"\\]+)|npm (test|start))$/.exec(
       command.trim(),
     )
   if (m === null) return null
   if (m[4] !== undefined) return m[4]
-  const [, manager, run, name] = m
+  const [, alias, run, name] = m
+  // `pn` is pnpm's own short name (pnpm 11; pnpm/pnpm's scripts run it).
+  const manager = alias === 'pn' ? 'pnpm' : alias
   // Bare, the manager's own command wins over a script of that name:
   // `bun test` is Bun's test runner and `bun build` its bundler, never the
   // `test` / `build` script, and a group over the script ran the wrong
@@ -155,7 +157,10 @@ function ownerOf(dir: string, memo: Map<string, Owner>): Owner {
   try {
     const pm = (JSON.parse(read('package.json') ?? '') as { packageManager?: unknown })
       .packageManager
-    if (typeof pm === 'string')
+    // A manager vx knows nothing of (zod's `nub@0.8.3`) says nothing about
+    // hooks: the lockfile beside it does, and "nub ran `postbuild`" was a
+    // claim nothing had checked (D-96).
+    if (typeof pm === 'string' && /^(npm|pnpm|yarn|bun)@/.test(pm))
       manager = /^yarn@([2-9]|\d{2,})/.test(pm) ? 'berry' : pm.split('@')[0]
   } catch {}
   if (manager === undefined) {
@@ -302,7 +307,7 @@ const MEMBER_FLAG =
 function pmRunsMembers(script: string): boolean {
   for (const segment of script.split(/&&|\|\||[;|()]/)) {
     const words = segment.trim().split(/\s+/)
-    let i = words.findIndex((w) => /^(pnpm|npm|yarn|bun)$/.test(w))
+    let i = words.findIndex((w) => /^(pnpm|pn|npm|yarn|bun)$/.test(w))
     // npm/cli runs itself: `node . run test --workspaces`.
     if (i < 0) i = words.findIndex((w, j) => w === 'run' && words[j - 2] === 'node')
     if (i < 0) continue
@@ -340,7 +345,45 @@ function cdsToMembers(script: string, rootDir: string, memberDirs: readonly stri
 
 /** A package manager running a script by name: `pnpm build`, `npm run x`, `bun run x`. */
 const RUNS_SCRIPT =
-  /(?:^|[\s;&|(])(?:pnpm|npm|yarn|bun)\s+(?:run(?:-script)?\s+)?([^\s;&|()'"-][^\s;&|()'"]*)/g
+  /(?:^|[\s;&|(])(?:pnpm|pn|npm|yarn|bun)\s+(?:run(?:-script)?\s+)?([^\s;&|()'"-][^\s;&|()'"]*)/g
+
+/**
+ * The scripts a command runs by name: a package manager's (`pnpm x`, `npm
+ * run x`), `run-s` / `run-p` / `npm-run-all` (`build:*` is one segment,
+ * `build:**` any), and `concurrently "npm:x"`. A root `ci: run-s build:all
+ * lint` over `build:all: pnpm -r build` mapped as a root task (D-95).
+ */
+function scriptRefs(command: string, scripts: readonly (readonly [string, string])[]): string[] {
+  const refs = [...command.matchAll(RUNS_SCRIPT)].map((m) => m[1]!)
+  for (const m of command.matchAll(/["']?\b(?:npm|pnpm|yarn|bun):([^\s"']+)/g)) refs.push(m[1]!)
+  for (const segment of command.split(/&&|\|\||[;|()]/)) {
+    const words = segment.trim().split(/\s+/)
+    const at = words.findIndex((w) => /^(run-s|run-p|npm-run-all)$/.test(w))
+    if (at < 0) continue
+    for (const w of words.slice(at + 1)) {
+      if (w.startsWith('-')) continue
+      const name = w.replace(/^(["'])(.*)\1$/, '$2')
+      if (!name.includes('*')) {
+        refs.push(name)
+        continue
+      }
+      const re = new RegExp(
+        `^${name
+          .split(/(\*\*|\*)/)
+          .map((part) =>
+            part === '**'
+              ? '.*'
+              : part === '*'
+                ? '[^:]*'
+                : part.replace(/[.+?^${}()|[\]\\]/g, '\\$&'),
+          )
+          .join('')}$`,
+      )
+      for (const [n] of scripts) if (re.test(n)) refs.push(n)
+    }
+  }
+  return refs
+}
 
 /**
  * The scripts that run the members, directly or through another of these
@@ -367,7 +410,7 @@ function runningMembers(
     grew = false
     for (const [n, v] of text) {
       if (out.has(n)) continue
-      if ([...v.matchAll(RUNS_SCRIPT)].some((m) => out.has(m[1]!))) {
+      if (scriptRefs(v, text).some((r) => out.has(r))) {
         out.add(n)
         grew = true
       }