@vzn/vx 0.0.638 → 0.0.640

package/src/cli/run.ts

@@ -1,18 +1,14 @@
-import { appendFileSync, mkdirSync } from 'node:fs'
-import path from 'node:path'
 import { isatty } from 'node:tty'
 import { cacheScopeError, findWorkspaceRoot, isCacheScope } from '../workspace/index.js'
 import { translateForeign } from './foreign-flags.js'
-import { flagHint, formatValue, refuse, seeHelp } from './help.js'
+import { flagHint, refuse, seeHelp } from './help.js'
 import {
   planRun,
-  formatRunReportMarkdown,
-  projectOutcome,
   run as runOrchestrator,
   shellQuote,
   type RunOptions,
 } from '../orchestrator/index.js'
-import type { ContinueMode, TaskOutcome } from '../graph/index.js'
+import type { ContinueMode } from '../graph/index.js'
 import {
   applyCacheFlags,
   type CacheFlags,
@@ -25,7 +21,7 @@ import { affectedFilterFor, findCwdSelection, pickTask, resolveFilters } from '.
 import { nxTargetHint, taskNamesHere } from './task-verb.js'
 import { parseDecimalInt, sayNotice, sayLine } from '../util/index.js'
 import { kindHint, parseSettingValue, type Setting, SETTINGS, settingRefusal } from '../settings.js'
-import { formatGraphDot, formatPlanJson, formatPlanText } from './plan-format.js'
+import { formatPlanJson, formatPlanText } from './plan-format.js'
 
 export interface RunArgs {
   /** Failure propagation (`--continue[=never|deps-ok|always]`). */
@@ -71,10 +67,6 @@ export interface RunArgs {
   forwardArgs: string[]
   verbosity: number
   dry: 'text' | 'json' | undefined
-  /** `--format json`: the run's result document on stdout, every other line on stderr. */
-  format: 'pretty' | 'json'
-  graph: string | undefined
-  summarize: string | undefined
   profile: string | undefined
   /**
    * `--affected[=<base>]`. When undefined the flag wasn't passed.
@@ -82,16 +74,6 @@ export interface RunArgs {
    * `defaultAffectedBase`). Any other string is an explicit git ref.
    */
   affected: string | undefined
-  /** `--tag k=v` pairs (repeatable). Empty key is a parse error. */
-  tags: Record<string, string>
-  /** `--report[=markdown]`. Undefined when the flag wasn't passed. */
-  report: 'markdown' | undefined
-  /**
-   * `--report-file=<path>`. Undefined when the flag wasn't passed. Writes
-   * the same markdown as `--report`, but to a file — because redirecting
-   * vx's stdout captures the whole run log, not just the report.
-   */
-  reportFile: string | undefined
   error?: string
 }
 
@@ -130,9 +112,6 @@ const SETTING_OPTIONS = [
   ['run.timeout', 'timeout'],
   ['run.retries', 'retries'],
   ['run.outputLogs', 'outputLogs'],
-  ['run.killGrace', 'killGrace'],
-  ['run.teardownTimeout', 'teardownTimeout'],
-  ['run.readyNotice', 'readyNotice'],
   ['cache.download', 'download'],
 ] as const satisfies readonly (readonly [string, keyof RunOptions])[]
 
@@ -150,14 +129,8 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
     forwardArgs: [],
     verbosity: 0,
     dry: undefined,
-    format: 'pretty',
-    graph: undefined,
-    summarize: undefined,
     profile: undefined,
     affected: undefined,
-    tags: {},
-    report: undefined,
-    reportFile: undefined,
   }
 
   // A Turbo or Nx spelling becomes vx's, or a refusal naming vx's.
@@ -301,58 +274,18 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
         return { ...out, error: `--dry must be text or json (got ${fmt})` }
       }
       out.dry = fmt
-    } else if (a === '--format' || a?.startsWith('--format=')) {
-      const f = formatValue(a === '--format' ? before[++i] : a.slice('--format='.length), verb)
-      if (typeof f !== 'string') return { ...out, error: f.error }
-      out.format = f
-    } else if (a === '--graph') {
-      out.graph = ''
-    } else if (a?.startsWith('--graph=')) {
-      out.graph = a.slice('--graph='.length)
-    } else if (a === '--summarize') {
-      out.summarize = ''
-    } else if (a?.startsWith('--summarize=')) {
-      out.summarize = a.slice('--summarize='.length)
     } else if (a === '--profile') {
       out.profile = 'profile.json'
     } else if (a?.startsWith('--profile=')) {
       // An optional-value flag: an empty `=` means "no value given", so it
       // takes the same documented default as the bare form. Resolving ''
       // against cwd would name the cwd DIRECTORY and die with EISDIR after
-      // the whole run — and `--summarize=` already degrades to its default.
+      // the whole run.
       out.profile = a.slice('--profile='.length) || 'profile.json'
     } else if (a === '--affected') {
       out.affected = ''
     } else if (a?.startsWith('--affected=')) {
       out.affected = a.slice('--affected='.length)
-    } else if (a === '--tag' || a?.startsWith('--tag=')) {
-      const raw = a === '--tag' ? before[++i] : a.slice('--tag='.length)
-      if (raw === undefined) return { ...out, error: `${a} requires a value (k=v)` }
-      // Split on the FIRST `=` so values may contain `=` (e.g. a URL).
-      const eq = raw.indexOf('=')
-      if (eq <= 0) return { ...out, error: `--tag must be k=v (got ${raw})` }
-      out.tags[raw.slice(0, eq)] = raw.slice(eq + 1)
-    } else if (a === '--report-file' || a?.startsWith('--report-file=')) {
-      const v = a === '--report-file' ? before[++i] : a.slice('--report-file='.length)
-      if (v === undefined || v === '') return { ...out, error: `--report-file requires a path` }
-      // Same reasoning as --cache-dir: a path is an arbitrary string, so
-      // nothing about its shape rejects a swallowed flag. A path starting
-      // with `-` needs the `=` form.
-      if (a === '--report-file' && v.startsWith('-')) {
-        return {
-          ...out,
-          error: `--report-file requires a path (got flag ${v}; a path that starts with - needs --report-file=${v})`,
-        }
-      }
-      out.reportFile = v
-    } else if (a === '--report') {
-      out.report = 'markdown'
-    } else if (a?.startsWith('--report=')) {
-      const fmt = a.slice('--report='.length)
-      if (fmt !== 'markdown') {
-        return { ...out, error: `--report must be markdown (got ${fmt})` }
-      }
-      out.report = fmt
     } else if (verb === 'watch' && a === '--poll') {
       out.poll = true
     } else if (a !== undefined && settingFlagOf(a) !== undefined) {
@@ -400,39 +333,10 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
   out.cache = applyCacheFlags(cachePolicy, flags)
   if (!cacheFlag && envSpec === undefined) out.cacheFlags = flags
 
-  if (out.dry !== undefined && out.graph !== undefined) {
-    return { ...out, error: '--dry and --graph are mutually exclusive' }
-  }
-  // Every flag that promises a file or a section about the run: the
-  // planning branch returns before any of them is written, and
-  // `--report-file="$GITHUB_STEP_SUMMARY" --dry` exited 0 having written
-  // nothing (item 992).
-  const needsRun =
-    out.summarize !== undefined ||
-    out.profile !== undefined ||
-    out.report !== undefined ||
-    out.reportFile !== undefined
-  const runOnly = '--summarize / --profile / --report / --report-file need a real run'
-  if (out.dry !== undefined && needsRun) {
-    return { ...out, error: `--dry skips execution; ${runOnly}` }
-  }
-  if (out.graph !== undefined && needsRun) {
-    return { ...out, error: `--graph skips execution; ${runOnly}` }
-  }
-  if (out.format === 'json') {
-    // Each of these prints something else on stdout, which the document owns.
-    if (out.dry !== undefined)
-      return { ...out, error: '--format json runs the tasks; --dry=json prints the plan' }
-    if (out.graph === '')
-      return {
-        ...out,
-        error: '--format json and --graph both print on stdout; give --graph a file',
-      }
-    if (out.report === 'markdown')
-      return {
-        ...out,
-        error: '--format json and --report=markdown both print on stdout; use --report-file',
-      }
+  // A profile is about a run: the planning branch returns before it is
+  // written (item 992).
+  if (out.dry !== undefined && out.profile !== undefined) {
+    return { ...out, error: '--dry skips execution; --profile needs a real run' }
   }
   return out
 }
@@ -619,10 +523,7 @@ export async function resolveRunOptions(
   for (const [path, field] of SETTING_OPTIONS) {
     if (parsed.settings[path] !== undefined) Object.assign(opts, { [field]: parsed.settings[path] })
   }
-  if (parsed.summarize !== undefined) opts.summarize = parsed.summarize
-  if (parsed.format === 'json') opts.json = true
   if (parsed.profile !== undefined) opts.profile = parsed.profile
-  if (Object.keys(parsed.tags).length > 0) opts.tags = parsed.tags
 
   return opts
 }
@@ -646,7 +547,7 @@ export async function runCmd(args: readonly string[]): Promise<number> {
   if (tasks.length === 0) {
     // A JSON answer is for a program, which cannot pick from a menu: an
     // agent on a pty waited at the picker forever.
-    const forProgram = parsed.format === 'json' || parsed.dry === 'json'
+    const forProgram = parsed.dry === 'json'
     if (!process.stdin.isTTY || forProgram) {
       const names = await taskNamesHere(cwd)
       const shown = (names ?? []).slice(0, TASKS_SHOWN)
@@ -710,17 +611,17 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     ...args.map(shellQuote),
   ].join(' ')
 
-  // Planning paths short-circuit execution. Both build the full task
-  // graph + probe the cache; the difference is just the formatter.
-  if (parsed.dry !== undefined || parsed.graph !== undefined) {
+  // Planning short-circuits execution: the full task graph + a cache probe.
+  if (parsed.dry !== undefined) {
     const plan = await planRun(opts)
+    // Refused as a run refuses: `--dry=json` gets the error document.
     if (plan.unresolvedTasks !== undefined && plan.unresolvedTasks.length > 0) {
-      sayNotice(
-        'error',
-        'vx run',
+      return refuse(
+        'run',
+        args,
         `no projects declare task(s): ${plan.unresolvedTasks.join(', ')}.${plan.unresolvedHint ?? ''}`,
+        'VX_E_UNKNOWN_TASK',
       )
-      return 1
     }
     if (plan.tasks.length === 0) {
       // The run's own line: a dry run that guessed from the scope alone
@@ -733,27 +634,14 @@ export async function runCmd(args: readonly string[]): Promise<number> {
         sayNotice('info', 'vx run', `no affected project declares task(s): ${tasks.join(', ')}`)
         return 0
       }
-      sayNotice('error', 'vx run', `no projects declare task(s): ${tasks.join(', ')}`)
-      return 1
+      return refuse(
+        'run',
+        args,
+        `no projects declare task(s): ${tasks.join(', ')}`,
+        'VX_E_UNKNOWN_TASK',
+      )
     }
-    if (parsed.graph !== undefined) {
-      const out = formatGraphDot(plan)
-      if (parsed.graph === '') {
-        process.stdout.write(out)
-      } else {
-        // The graph is the command's one product, so a path it cannot write
-        // is exit 1, said in one line as the other output paths say theirs:
-        // a directory or an unreachable path printed a raw stack (item 993).
-        const target = path.resolve(cwd, parsed.graph)
-        try {
-          await Bun.write(target, out)
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err)
-          sayNotice('error', 'vx run', `failed to write graph to ${target}: ${message}`)
-          return 1
-        }
-      }
-    } else if (parsed.dry === 'json') {
+    if (parsed.dry === 'json') {
       process.stdout.write(formatPlanJson(plan, scopeOut.affectedBase))
     } else {
       process.stdout.write(formatPlanText(plan))
@@ -761,25 +649,6 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     return 0
   }
 
-  // The report prints above the footer: nothing prints below it (owner).
-  // Rendered once, however many sinks asked for it; a kept server's crash
-  // after the footer re-renders the file's copy (C-53).
-  const wantsReport = parsed.report === 'markdown' || parsed.reportFile !== undefined
-  let reported: { outcomes: readonly TaskOutcome[]; md: string } | undefined
-  if (wantsReport) {
-    opts.beforeFooter = (outcomes, ok) => {
-      reported = {
-        outcomes,
-        md: formatRunReportMarkdown({ ok, outcomes: outcomes.map(projectOutcome) }),
-      }
-      // `--report` writes stdout. The report ITSELF is machine-clean, but
-      // stdout is not vx's alone — the status logger writes there too, so
-      // `--report=markdown >> "$GITHUB_STEP_SUMMARY"` captures every frame,
-      // meter bar and `::group::` command above the table. `--report-file`
-      // is the redirect-free form.
-      return parsed.report === 'markdown' ? reported.md : ''
-    }
-  }
   // A run executes in THIS process, always. Where an individual task's
   // command runs is the `executor` capability's business (per task, with
   // the scheduler, cache, retries and telemetry unchanged above it); there
@@ -789,37 +658,6 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     const unknown = summary.refused.startsWith('no projects declare')
     return refuse('run', args, summary.refused, unknown ? 'VX_E_UNKNOWN_TASK' : 'VX_E_REFUSED')
   }
-  if (wantsReport) {
-    const md =
-      reported?.outcomes === summary.outcomes
-        ? reported.md
-        : formatRunReportMarkdown({
-            ok: summary.ok,
-            outcomes: summary.outcomes.map(projectOutcome),
-          })
-    if (parsed.reportFile !== undefined) {
-      const target = path.resolve(cwd, parsed.reportFile)
-      try {
-        // APPEND, not overwrite: the flag exists for `$GITHUB_STEP_SUMMARY`,
-        // which GitHub documents as append-only and which other steps in the
-        // same job also write to. Truncating it would silently destroy their
-        // content, and would make replacing the documented `>>` recipe a
-        // behaviour change rather than a drop-in.
-        // Its directory made first, as `--summarize`, `--profile` and
-        // `--graph` make theirs: `nr/r.md` failed alone of the four (item 993).
-        // Sync: on a Ctrl-C the signal path exits once stdout drains, and
-        // an awaited write lost the race every time (E-23).
-        mkdirSync(path.dirname(target), { recursive: true })
-        appendFileSync(target, md)
-      } catch (err) {
-        // Same contract as --summarize / --profile: the run already
-        // happened, so a write failure is reported, not fatal.
-        const message = err instanceof Error ? err.message : String(err)
-        sayNotice('warn', 'vx run', `failed to write report to ${target}: ${message}`)
-      }
-    }
-  }
-  if (summary.json !== undefined) process.stdout.write(`${JSON.stringify(summary.json)}\n`)
   return summary.ok ? 0 : 1
 }
 

package/src/cli/select.ts

@@ -51,7 +51,7 @@ import {
 import { resolveSetting } from '../settings.js'
 
 /**
- * The projects whose tasks declare a `cache.inputs.workspaceFiles` glob
+ * The projects whose tasks declare an `inputs.workspaceFiles` glob
  * matching a changed path, one inside another project included (item
  * 954): `--affected` selects them, since the glob is that task's input. Through the run
  * path's staged load, so a glob a `project` plugin gave a config-less
@@ -71,10 +71,8 @@ export async function workspaceGlobOwners(
 ): Promise<string[]> {
   const declaresMatch = (config: ProjectConfig): boolean => {
     for (const task of Object.values(config.tasks ?? {})) {
-      const cache = task.cache
-      if (cache === undefined) continue
-      if (changed.some((rel) => declaresInput(cache, null, rel))) return true
-      if (nested.some((dir) => workspaceFilesReachInto(cache, dir))) return true
+      if (changed.some((rel) => declaresInput(task, null, rel))) return true
+      if (nested.some((dir) => workspaceFilesReachInto(task, dir))) return true
     }
     return false
   }
@@ -335,7 +333,19 @@ export async function resolveFilters(
         workspaceGlobOwners: (changed: readonly string[], nested: readonly string[]) =>
           workspaceGlobOwners(root, projects, changed, load, stagedOnce, nested),
         fingerprintClaims: () => workspaceFingerprintClaims(root, projects, load),
-        ...(git !== undefined ? { untracked: async () => (await git.start()).untracked } : {}),
+        ...(git !== undefined
+          ? {
+              untracked: async () => (await git.start()).untracked,
+              // A scoped enumeration lists only its projects: null asks git.
+              links: async () => {
+                const g = await git.start()
+                if (!g.scopes.includes('.')) return null
+                const out: string[] = []
+                for (const [rel, oid] of g.trusted) if (oid.startsWith('120000:')) out.push(rel)
+                return out
+              },
+            }
+          : {}),
       }
       let names: Set<string>
       if (f.raw === affected) {

package/src/cli/show.ts

@@ -169,6 +169,12 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const projects = await loadCliProjects(root, metas, scope, { closure: true })
 
   if (parsed.target === undefined) {
+    if (metas.length === 0)
+      sayNotice(
+        'info',
+        'vx show',
+        'no projects: no directory holds a vx.config — run `vx init` to write them, then `vx lock`',
+      )
     const shown = metas.filter((m) => inSelection(m.name))
     process.stdout.write(renderList(root, shown, projects, parsed.format, colorsOut()))
     return 0
@@ -460,14 +466,17 @@ function taskRows(raw: TaskConfig): ui.FieldRow[] {
     )
   }
   add('interactive', exec?.interactive === undefined ? undefined : exec.interactive ? 'yes' : 'no')
+  const inputs = task.inputs
+  if (inputs !== undefined) {
+    add('inputs.files', list(inputs.files))
+    add('inputs.workspaceFiles', list(inputs.workspaceFiles))
+    add('inputs.env', list(inputs.env))
+    add('inputs.tasks', list(inputs.tasks))
+    add('inputs.runtime', list(inputs.runtime))
+    add('inputs.workspaceRuntime', list(inputs.workspaceRuntime))
+  }
   const cache = task.cache
   if (cache !== undefined) {
-    add('inputs.files', list(cache.inputs.files))
-    add('inputs.workspaceFiles', list(cache.inputs.workspaceFiles))
-    add('inputs.env', list(cache.inputs.env))
-    add('inputs.tasks', list(cache.inputs.tasks))
-    add('inputs.runtime', list(cache.inputs.runtime))
-    add('inputs.workspaceRuntime', list(cache.inputs.workspaceRuntime))
     add('outputs.files', list(cache.outputs.files))
     add('outputs.workspaceFiles', list(cache.outputs.workspaceFiles))
   }