@vzn/vx 0.0.276 → 0.0.278

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.276",
+  "version": "0.0.278",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.276",
-    "@vzn/vx-linux-arm64": "0.0.276",
-    "@vzn/vx-darwin-x64": "0.0.276",
-    "@vzn/vx-darwin-arm64": "0.0.276"
+    "@vzn/vx-linux-x64": "0.0.278",
+    "@vzn/vx-linux-arm64": "0.0.278",
+    "@vzn/vx-darwin-x64": "0.0.278",
+    "@vzn/vx-darwin-arm64": "0.0.278"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/show.ts

@@ -6,6 +6,7 @@
 // <task>`: one task. `<task>`: that task in every project declaring it.
 // Deliberately NOT the lock — vx-lock.json is already the frozen JSON.
 
+import path from 'node:path'
 import type { ProjectConfig, TaskConfig } from '../config.js'
 import { declaredTask } from '../graph/index.js'
 import { flagHint, seeHelp } from './help.js'
@@ -65,6 +66,10 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const metas = await discoverCliProjects(await loadWorkspace(root, reads))
   const byName = new Map(metas.map((m) => [m.name, m]))
 
+  // `//#task` is Turbo's root package's task: the root project here (D-39).
+  const rootMeta = metas.find((m) => path.resolve(m.dir) === path.resolve(root))
+  if (parsed.target?.startsWith('//#') && rootMeta !== undefined)
+    parsed.target = `${rootMeta.name}#${parsed.target.slice(3)}`
   const hashAt = parsed.target?.indexOf('#') ?? -1
   const projectName =
     parsed.target === undefined

package/src/cli/why.ts

@@ -5,6 +5,7 @@
 // names the exact cache-key components that differ. Read-only over cache.db —
 // no config evaluation, no re-hash.
 
+import path from 'node:path'
 import { Cache, noteSchemaReset } from '../cache/index.js'
 import { flagHint, seeHelp } from './help.js'
 import { splitTaskId } from '../graph/index.js'
@@ -159,6 +160,16 @@ function resolveTarget(cache: Cache, target: string): string {
 
 const fmtWhen = (ms: number): string => new Date(ms).toISOString()
 
+/** `//#task`, Turbo's root package, as the root project's id: its package.json name (D-39). */
+async function rootSpelled(root: string, target: string): Promise<string> {
+  if (!target.startsWith('//#')) return target
+  const name = await Bun.file(path.join(root, 'package.json'))
+    .json()
+    .then((j: { name?: unknown }) => j.name)
+    .catch(() => undefined)
+  return typeof name === 'string' && name !== '' ? `${name}#${target.slice(3)}` : target
+}
+
 export async function whyCmd(args: readonly string[]): Promise<number> {
   const parsed = parseWhyArgs(args)
   if (parsed.error !== undefined) throw new UserError(`vx why: ${parsed.error}`)
@@ -171,7 +182,7 @@ export async function whyCmd(args: readonly string[]): Promise<number> {
   noteSchemaReset(cache, warnToStderr)
   try {
     const db = cache.dbHandle()
-    const taskId = resolveTarget(cache, parsed.target)
+    const taskId = resolveTarget(cache, await rootSpelled(root, parsed.target))
     const runId =
       parsed.runId !== undefined
         ? (resolveRunId(db, parsed.runId, 'vx why') ?? parsed.runId)

package/src/graph/task-graph.ts

@@ -479,6 +479,11 @@ export function buildTaskGraph(options: BuildGraphOptions): Map<string, TaskNode
       // Cross-project edge: pkg#task. Missing target is a hard error
       // because the user named the package + task explicitly.
       if (!visit(frame, spec.project, spec.task, false)) {
+        // The loader spells `//` as the root project's name when there is one.
+        if (spec.project === '//')
+          throw new UserError(
+            `Task ${id} depends on //#${spec.task}, Turbo's root package, but the workspace root is no project here: give it a package.json name and a vx.config with that task`,
+          )
         throw new UserError(
           `Task ${id} depends on ${taskId(spec.project, spec.task)} but no such project or task is declared`,
         )

package/src/orchestrator/projects.ts

@@ -4,6 +4,7 @@
 // plugin `project` stage, which can give tasks to a package that never
 // wrote a `vx.config.ts`.
 
+import path from 'node:path'
 import type { ProjectConfig } from '../config.js'
 import {
   frozenProjectConfig,
@@ -198,6 +199,12 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
   // deps by design), so its config has to be pulled in — and that config
   // may declare cross edges of its own. The common case (no cross deps)
   // is a single round, identical to loading the closure in one batch.
+  // Turbo spells the root package `//` (`dependsOn: ['//#lint']`); vx names
+  // the root project by its package.json name, so the spelling is rewritten
+  // to it once, here, for the closure, the graph and `cache.inputs.tasks`
+  // alike. With no root project it stays, and the graph's refusal says so.
+  const root = path.resolve(workspaceRoot)
+  const rootName = args.projectMetas.find((m) => path.resolve(m.dir) === root)?.name
   const projects = new Map<string, ProjectEntry>()
   while (pending.length > 0) {
     const round = pending.splice(0, pending.length)
@@ -248,8 +255,9 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
           (plugin) => validateProjectConfig(config, `${where} (after plugin '${plugin.name}')`),
         )
       }
-      projects.set(meta.name, { name: meta.name, dir: meta.dir, config })
-      for (const name of crossDepProjects(config)) {
+      const named = rootName === undefined ? config : rootSpelled(config, rootName)
+      projects.set(meta.name, { name: meta.name, dir: meta.dir, config: named })
+      for (const name of crossDepProjects(named)) {
         if (args.closure) considerWithDeps(name)
         else consider(name)
       }
@@ -258,6 +266,33 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
   return { projects, configured }
 }
 
+/**
+ * `config` with Turbo's `//#task` (in `dependsOn` and `cache.inputs.tasks`)
+ * spelled `<root>#task`; the same object when it holds none. A copy, not
+ * an edit: a loaded config may be a cached or a frozen one.
+ */
+function rootSpelled(config: ProjectConfig, rootName: string): ProjectConfig {
+  const fix = (list: readonly string[] | undefined): readonly string[] | undefined =>
+    list?.some((e) => e.startsWith('//#') || e.startsWith('!//#'))
+      ? list.map((e) => e.replace(/^(!?)\/\/#/, `$1${rootName}#`))
+      : list
+  let tasks: NonNullable<ProjectConfig['tasks']> | undefined
+  for (const [name, task] of Object.entries(config.tasks ?? {})) {
+    const dependsOn = fix(task.dependsOn)
+    const inputTasks = fix(task.cache?.inputs?.tasks)
+    if (dependsOn === task.dependsOn && inputTasks === task.cache?.inputs?.tasks) continue
+    tasks ??= { ...config.tasks }
+    tasks[name] = {
+      ...task,
+      ...(dependsOn !== undefined ? { dependsOn: [...dependsOn] } : {}),
+      ...(task.cache?.inputs !== undefined && inputTasks !== undefined
+        ? { cache: { ...task.cache, inputs: { ...task.cache.inputs, tasks: [...inputTasks] } } }
+        : {}),
+    }
+  }
+  return tasks === undefined ? config : { ...config, tasks }
+}
+
 /** Project names named by a `pkg#task` dependsOn entry anywhere in `config`. */
 function crossDepProjects(config: ProjectConfig): string[] {
   const out: string[] = []