@vzn/vx 0.0.595 → 0.0.596

package/src/workspace/filter.ts

@@ -5,6 +5,8 @@
 //   {<dir>}          same as ./<dir>
 //   //               the workspace-root project only (Turbo's name for the root)
 //   tag:<pattern>    the projects whose config `tags` hold a match (Nx's `tag:`)
+//   <dir>/<glob>     a name with a `/` outside a scope that names no project:
+//                    ./<dir>/<glob> (Nx's `--projects 'apps/*'`)
 //   <pattern>...     pattern + its transitive workspace dependencies
 //   ...<pattern>     pattern + its transitive workspace dependents
 //   <pattern>^...    only the transitive deps of pattern (excluding the matched package)
@@ -58,6 +60,11 @@ export interface ParsedFilter {
   exactDir?: true
   /** `tag:<pattern>`: `matcher` is a glob over the projects' tags, not their names. */
   tag?: true
+  /**
+   * `apps/*`: a name pattern holding a `/` outside a scope, read as
+   * `./apps/*` when it names no project, as Nx's `--projects` reads it.
+   */
+  dirFallback?: ParsedFilter
 }
 
 export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
@@ -187,6 +194,15 @@ export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
     }
   }
 
+  // A package name holds a `/` only after its `@scope`, so `apps/*` is a
+  // directory for every project named after its package.json; Nx matches
+  // a `--projects` entry by name, then by root (find-matching-projects,
+  // 23.2.1), and `-p 'apps/*'` matched nothing here.
+  const dirFallback =
+    !isPath && s.includes('/') && !s.startsWith('@')
+      ? parseFilter(`./${s}`, workspaceRoot)
+      : undefined
+
   return {
     raw,
     negate,
@@ -196,6 +212,7 @@ export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
     onlyDependents,
     isPath,
     matcher,
+    ...(dirFallback !== undefined ? { dirFallback } : {}),
     ...(pathGlob !== undefined ? { pathGlob, pathRoot: workspaceRoot } : {}),
     ...(pathGlobBase !== undefined ? { pathGlobBase } : {}),
     ...(gitSince !== undefined ? { gitSince } : {}),
@@ -278,6 +295,8 @@ function matchSelector(
   for (const p of projects) {
     if (re.test(p.name)) out.push(p.name)
   }
+  if (out.length === 0 && filter.dirFallback !== undefined)
+    return matchSelector(filter.dirFallback, projects, tags)
   if (out.length > 0 || filter.matcher.includes('/')) return out
   // pnpm's rule: the scope may be left out (`--filter core` is
   // `@babel/core`), an exact name only when one package carries it. Nx

package/src/workspace/migrate-scripts.ts

@@ -429,7 +429,8 @@ function pmRunsMembers(script: string): boolean {
   return false
 }
 
-const CD = /(?:^|[\s;&|(])cd\s+("[^"]*"|'[^']*'|[^\s;&|()]+)/g
+// A bare target may escape a space or paren (`cd packages/my\ app`).
+const CD = /(?:^|[\s;&|(])cd\s+("[^"]*"|'[^']*'|(?:\\.|[^\s;&|()\\])+)/g
 
 /**
  * A `cd` into a member's directory, or one holding members, runs that
@@ -439,7 +440,8 @@ const CD = /(?:^|[\s;&|(])cd\s+("[^"]*"|'[^']*'|[^\s;&|()]+)/g
  */
 function cdsToMembers(script: string, rootDir: string, memberDirs: readonly string[]): boolean {
   for (const m of script.matchAll(CD)) {
-    const target = m[1]!.replace(/^(["'])(.*)\1$/, '$2')
+    const quoted = /^(["'])(.*)\1$/.exec(m[1]!)
+    const target = quoted ? quoted[2]! : m[1]!.replace(/\\(.)/g, '$1')
     if (/[$`~*?]/.test(target) || target === '-') return true
     const dir = path.resolve(rootDir, target)
     const inside = (a: string, b: string): boolean => a === b || a.startsWith(b + path.sep)

package/src/workspace/migration.ts

@@ -406,7 +406,7 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
       : []
   if (empty && unreached.length > 0) {
     report.push(
-      `${verb}: ${unreachedHint(unreached)}`,
+      `${verb}: ${unreachedHint(unreached, root)}`,
       hasWorkspaceFile
         ? `${workspaceName} already exists.`
         : dry

package/src/workspace/project-loader.ts

@@ -127,10 +127,12 @@ function servableSource(bytes: Uint8Array, loader: 'ts' | 'js'): string | null {
 }
 
 // What makes Bun run a file as CommonJS is one of these names at the top
-// level (an escaped `\u006dodule` too, so any backslash counts). Source
+// level (an escaped `\u006dodule` too, so any backslash counts), or
+// TypeScript's `export =`, which spells none of them. Source
 // with none of them runs as a module whichever path loads it, so it skips
 // the parse: 16–20 µs a config, 1,000 cold configs (2026-10-03).
-const COMMONJS_HINT = /\b(?:module|exports|require|this|__dirname|__filename)\b|\\/
+const COMMONJS_HINT =
+  /\b(?:module|exports|require|this|__dirname|__filename)\b|\\|\bexport\s*=(?!=)/
 
 /** vx's module-cache query, which no user wrote: stripped from anything shown to them. */
 const BUST_QUERY = /\?vx-(?:bust|held)=[^'"\s]*/g

package/src/workspace/repo-id.ts

@@ -13,6 +13,7 @@ import {
   lstatSync,
   openSync,
   readFileSync,
+  realpathSync,
   statSync,
 } from 'node:fs'
 import path from 'node:path'
@@ -25,12 +26,20 @@ import path from 'node:path'
  * git: those share nothing.
  */
 export async function repoIdOf(root: string): Promise<string | null> {
-  const located = locateGitDir(root)
+  // Git walks the physical path; the logical one found no `.git` through a
+  // symlink from outside the repository, and an alias inside it another id.
+  let real: string
+  try {
+    real = realpathSync(root)
+  } catch {
+    real = path.resolve(root)
+  }
+  const located = locateGitDir(real)
   if (located === null) return null
   const identity =
     (await remoteIdentity(root, located.commonDir)) ?? (await firstCommit(located.commonDir, root))
   if (identity === null) return null
-  const rel = path.relative(located.gitRoot, path.resolve(root)).split(path.sep).join('/')
+  const rel = path.relative(located.gitRoot, real).split(path.sep).join('/')
   const key = sha256(`${identity}#${rel}`)
   return sha256(key).slice(0, 16)
 }
@@ -108,11 +117,40 @@ function readOwnedFile(p: string): string | null {
   }
 }
 
-/** The remote's identity from the config file, else from `git remote -v`. */
+/**
+ * The remote's identity from the config file, else from `git remote -v`
+ * when the file cannot settle it: a remote none of whose urls parse (a
+ * rewrite may live in a file vx does not read, as Nx asks git), or
+ * remotes git could read from `config.worktree`.
+ */
 async function remoteIdentity(root: string, commonDir: string): Promise<string | null> {
   const config = readOwnedFile(path.join(commonDir, 'config'))
   const remotes = config === null ? null : parseGitConfigRemotes(config)
-  const urls = remotes ?? (await remotesFromGit(root))
+  if (remotes !== null) {
+    const picked = pickRemote(remotes)
+    // A remote-less repo with nothing to pull one from elsewhere spawns
+    // nothing: git would answer the same, and that spawn was a cost per run.
+    if (picked !== null || (remotes.length === 0 && !worktreeConfigOn(config!))) return picked
+  }
+  return pickRemote(await remotesFromGit(root))
+}
+
+/** `extensions.worktreeConfig` set: git reads `config.worktree` too. */
+function worktreeConfigOn(contents: string): boolean {
+  let inExtensions = false
+  for (const raw of contents.split('\n')) {
+    const line = raw.trim()
+    if (line.startsWith('[')) {
+      inExtensions = /^\[\s*extensions\s*\]/i.test(line)
+      continue
+    }
+    const m = /^worktreeconfig\s*(?:=\s*(\S*))?/i.exec(line)
+    if (inExtensions && m !== null && !/^(false|no|off|0)$/i.test(m[1] ?? 'true')) return true
+  }
+  return false
+}
+
+function pickRemote(urls: [string, string][]): string | null {
   const found = new Map<string, string>()
   let first: string | null = null
   for (const [name, url] of urls) {

package/src/workspace/workspace.ts

@@ -1,4 +1,4 @@
-import { constants, type Dirent } from 'node:fs'
+import { constants, existsSync, type Dirent } from 'node:fs'
 import { access, readdir, realpath, stat } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import path from 'node:path'
@@ -267,11 +267,13 @@ async function readRootManifests(
       }
       catalogs = catalogsOf([parsed])
       const packages = (parsed as { packages?: unknown }).packages
-      if (packages !== undefined) {
+      // A list commented out leaves `packages:` null, which pnpm reads as
+      // absent; vx refused it as "must be an array" (D-149).
+      if (packages !== undefined && packages !== null) {
         return { globs: assertGlobList(packages, yamlPath, 'packages'), catalogs }
       }
     }
-    // No `packages:`: pnpm 10 keeps its settings and catalogs in this file
+    // No `packages:` (or an empty one): pnpm 10 keeps its settings and catalogs in this file
     // for a single-package repo too. The root's package.json decides, as it
     // would without the file; read as an empty list, the root found zero
     // projects and every verb ran nothing and exited 0 (item 984).
@@ -348,8 +350,13 @@ export async function unreachedPackages(workspace: Workspace): Promise<string[]>
   return found.sort()
 }
 
-/** The line for `unreachedPackages`' finding: the cause, the packages, the glob to add. */
-export function unreachedHint(unreached: readonly string[]): string {
+/**
+ * The line for `unreachedPackages`' finding: the cause, the packages, the
+ * glob to add, and where. A `pnpm-workspace.yaml` with no `packages:` (pnpm
+ * keeps its settings there) is where pnpm reads the globs: the hint said
+ * there was no such file and named package.json, beside ngrx's (2026-10-07).
+ */
+export function unreachedHint(unreached: readonly string[], root: string): string {
   const n = unreached.length
   const shown = unreached.slice(0, 3).join(', ') + (n > 3 ? ` and ${n - 3} more` : '')
   const globs = [
@@ -357,11 +364,11 @@ export function unreachedHint(unreached: readonly string[]): string {
   ]
     .map((g) => `"${g}"`)
     .join(', ')
-  return (
-    `package.json declares no \`workspaces\` (and there is no pnpm-workspace.yaml), so the root is the only project ` +
-    `and ${n} package.json below it ${n === 1 ? 'is' : 'are'} not: ${shown}. ` +
-    `Add \`"workspaces": [${globs}]\` to package.json and re-run.`
-  )
+  const rest = `so the root is the only project and ${n} package.json below it ${n === 1 ? 'is' : 'are'} not: ${shown}.`
+  return existsSync(path.join(root, 'pnpm-workspace.yaml'))
+    ? `pnpm-workspace.yaml lists no \`packages\`, ${rest} Add \`packages: [${globs}]\` to pnpm-workspace.yaml and re-run.`
+    : `package.json declares no \`workspaces\` (and there is no pnpm-workspace.yaml), ${rest} ` +
+        `Add \`"workspaces": [${globs}]\` to package.json and re-run.`
 }
 
 /**