@vzn/vx 0.0.652 → 0.0.653

package/src/cli/show.ts

@@ -6,11 +6,12 @@
 // resolved config. `<pkg>#<task>`: one task. `<task>`: that task in every
 // project declaring it.
 
+import { existsSync } from 'node:fs'
 import path from 'node:path'
 import type { ProjectConfig, TaskConfig } from '../config.js'
 import { declaredTask } from '../graph/index.js'
 import { isDefaultBuild } from '../graph/index.js'
-import { affectedTaskProjects } from '../orchestrator/index.js'
+import { affectedTaskProjects, projectAtDir, unlockedDir } from '../orchestrator/index.js'
 import { flagHint, formatValue, refuse, seeHelp } from './help.js'
 import {
   listed,
@@ -22,7 +23,7 @@ import {
 } from '../util/index.js'
 import * as ui from '../ui/index.js'
 import { sayNotice } from '../ui/index.js'
-import { affectedFilterFor, resolveFilters } from './select.js'
+import { type AffectedFilter, affectedFilterFor, resolveFilters } from './select.js'
 import {
   discoverCliProjects,
   loadCliProjects,
@@ -34,6 +35,7 @@ import {
   buildPackageGraph,
   EMPTY_LOCK,
   findWorkspaceRoot,
+  PROJECT_CONFIG_FILENAMES,
   type ProjectEntry,
   type ProjectMeta,
 } from '../workspace/index.js'
@@ -113,6 +115,22 @@ export async function showCmd(args: readonly string[]): Promise<number> {
     }
     parsed.target = `${rootMeta.name}${parsed.target.slice(2)}`
   }
+  // A project's directory typed for its name: by edit distance, `p/a`
+  // hinted `p/b`, another project.
+  const atDir = (typed: string, suffix: string): string | undefined => {
+    const name = projectAtDir(typed, root, metas)
+    return name === undefined ? undefined : ` — did you mean ${name}${suffix}?`
+  }
+  // A directory whose config came after the lock: the line `vx run` gives,
+  // not "unknown project" and a guess.
+  const refuseUnlocked = async (typed: string): Promise<void> => {
+    const config = await unlockedDir(typed, metas, root)
+    if (config === undefined) return
+    throw new UserError(
+      `${parsed.target}: ${relPosix(root, config)} is not in the lock yet — run \`vx lock\``,
+      'VX_E_LOCK',
+    )
+  }
   const hashAt = parsed.target?.indexOf('#') ?? -1
   const projectName =
     parsed.target === undefined
@@ -136,8 +154,9 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   }
   if (projectName !== undefined && (taskName !== undefined || byName.has(projectName))) {
     if (!byName.has(projectName)) {
+      await refuseUnlocked(projectName)
       throw new UserError(
-        `vx show: unknown project: "${projectName}"${suggest(projectName, [...byName.keys()], '', 'projects')}`,
+        `vx show: unknown project: "${projectName}"${atDir(projectName, `#${taskName}`) ?? suggest(projectName, [...byName.keys()], '', 'projects')}`,
         'VX_E_UNKNOWN_PROJECT',
       )
     }
@@ -161,16 +180,16 @@ export async function showCmd(args: readonly string[]): Promise<number> {
       )
     }
     const raw = [...parsed.filters]
-    let affected: string | undefined
+    let affected: AffectedFilter | undefined
     if (parsed.affected !== undefined) {
       const f = await affectedFilterFor(
         process.cwd(),
         parsed.affected,
         'drop --affected to list them all',
       )
-      if (typeof f === 'object') throw new UserError(`vx show: ${f.error}`, f.code ?? 'VX_E_USAGE')
+      if ('error' in f) throw new UserError(`vx show: ${f.error}`, f.code ?? 'VX_E_USAGE')
       affected = f
-      raw.unshift(f)
+      raw.unshift(f.filter)
     }
     const r = await resolveFilters(process.cwd(), raw, {}, affected, 'show')
     if ('error' in r) throw new UserError(`vx show: ${r.error}`, r.code ?? 'VX_E_USAGE')
@@ -203,13 +222,14 @@ export async function showCmd(args: readonly string[]): Promise<number> {
       declares(declaredTask(p.config, projectName!)),
     )
     if (declaring.length === 0) {
+      await refuseUnlocked(projectName!)
       const names = new Set<string>()
       for (const p of projects.values())
         for (const [t, task] of Object.entries(p.config.tasks ?? {}))
           if (declares(task)) names.add(t)
       // `nx show projects` lists them; here a bare `vx show` does.
       const nx = projectName === 'projects' ? ' (`nx show projects` is `vx show` here)' : ''
-      const unknown = `vx show: unknown project or task: "${projectName}"${nx}${suggest(projectName!, [...byName.keys(), ...names], '', 'projects and tasks')}`
+      const unknown = `vx show: unknown project or task: "${projectName}"${nx}${atDir(projectName!, '') ?? suggest(projectName!, [...byName.keys(), ...names], '', 'projects and tasks')}`
       const base =
         parsed.spacedBase === projectName
           ? `${unknown.endsWith('.') ? '' : '.'} \`--affected\` takes its base with '=': --affected=${projectName}`
@@ -258,7 +278,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const dir = projectDir(root, meta)
 
   if (taskName === undefined) {
-    emit(renderProject(meta.name, dir, config, meta.configPath !== null, parsed.format))
+    emit(renderProject(meta.name, dir, config, configNote(meta), parsed.format))
     return 0
   }
 
@@ -369,7 +389,9 @@ function renderList(
       tags: projects.get(meta.name)?.config.tags ?? [],
       tasks: Object.keys(tasks),
       onlyDefault: Object.values(tasks).every((t) => isDefaultBuild(t)),
+      hasDefault: Object.values(tasks).some((t) => isDefaultBuild(t)),
       configured: meta.configPath !== null,
+      note: configNote(meta),
     }
   })
   if (format === 'json') {
@@ -383,23 +405,38 @@ function renderList(
     // A package with no config file has only tasks a plugin gave it, or the
     // default `build` a configured dependant's closure gave it.
     const tasks = r.configured
-      ? count
-      : n === 0
-        ? 'no vx config'
-        : r.onlyDefault
-          ? `${count}, default build (no vx config)`
-          : `${count} from plugins (no vx config)`
+      ? r.tasks.length > 0 && r.hasDefault
+        ? `${count}, default build`
+        : count
+      : r.note !== null && r.note !== 'none'
+        ? r.note
+        : n === 0
+          ? 'no vx config'
+          : r.onlyDefault
+            ? `${count}, default build (no vx config)`
+            : `${count} from plugins (no vx config)`
     return [ui.id(r.name), r.dir, tasks, ...(anyTags ? [r.tags.join(', ')] : [])]
   })
   const columns = ['project', 'dir', 'tasks', ...(anyTags ? ['tags'] : [])]
   return [ui.section('Projects', String(rows.length), ui.table(columns, cells))]
 }
 
+/**
+ * Null for a project the lock holds a config for; else `none`, or a config
+ * written after the lock: "no vx config" sent a user who had just written
+ * one looking for a typo.
+ */
+function configNote(meta: ProjectMeta): string | null {
+  if (meta.configPath !== null) return null
+  const file = PROJECT_CONFIG_FILENAMES.find((n) => existsSync(path.join(meta.dir, n)))
+  return file === undefined ? 'none' : `${file} not locked — run vx lock`
+}
+
 function renderProject(
   name: string,
   dir: string,
   config: ProjectConfig | null,
-  hasConfigFile: boolean,
+  note: string | null,
   format: 'pretty' | 'json',
 ): Shown {
   if (format === 'json') {
@@ -414,11 +451,16 @@ function renderProject(
     ['dir', dir],
     ...(tags.length > 0 ? [['tags', tags.join(', ')] as const] : []),
     // A config-less package a dependant reaches has the default `build` (X-9).
-    ...(hasConfigFile ? [] : [['config', 'none'] as const]),
-    ...(tasks.length === 0 && hasConfigFile ? [['tasks', 'none declared'] as const] : []),
+    ...(note === null ? [] : [['config', note] as const]),
+    ...(tasks.length === 0 && note === null ? [['tasks', 'none declared'] as const] : []),
   ]
   const blocks = tasks.map(([taskName, task]) =>
-    joined([ui.text(ui.id(`${name}#${taskName}`)), ui.fields(taskRows(task))]),
+    joined([
+      isDefaultBuild(task)
+        ? ui.line('  ', ui.id(`${name}#${taskName}`), ui.dim('  default'))
+        : ui.text(ui.id(`${name}#${taskName}`)),
+      ui.fields(taskRows(task)),
+    ]),
   )
   return [ui.section(name, ui.fields(head), ...blocks)]
 }
@@ -516,5 +558,8 @@ function taskRows(raw: TaskConfig): ui.FieldRow[] {
     add('outputs.workspaceFiles', list(outputs.workspaceFiles))
     add('outputs.clean', outputs.clean === undefined ? undefined : outputs.clean ? 'yes' : 'no')
   }
+  // The first question `vx why` raises ("declares no `cache: true`"), which
+  // only --format json answered.
+  if (task.cache === true) add('cache', 'yes')
   return rows
 }

package/src/cli/task-verb.ts

@@ -68,20 +68,25 @@ export async function nxTargetHint(tasks: readonly string[], cwd: string): Promi
 }
 
 /**
- * The task names `vx run <task>` can take here: the cwd project's, else
- * every project's, sorted; null when no workspace loads. What a run with
- * no task and no terminal for the picker names instead of a guess.
+ * The task names `vx run <task>` can take in the asked scope (`asked`: the
+ * projects `--filter` / `--affected` selected, or `all`), else the cwd
+ * project's, else every project's, sorted; null when no workspace loads.
+ * What a run with no task and no terminal for the picker names instead of
+ * a guess.
  */
-export async function taskNamesHere(cwd: string): Promise<string[] | null> {
+export async function taskNamesHere(
+  cwd: string,
+  asked?: ReadonlySet<string> | 'all',
+): Promise<{ names: string[]; inProject: boolean } | null> {
   const projects = await workspaceProjects(cwd)
   if (projects === null) return null
-  const own = await findCwdProject(cwd)
+  const own = asked === undefined ? await findCwdProject(cwd) : null
   const names = new Set<string>()
   for (const p of projects.values())
-    if (own === null || p.name === own)
+    if (typeof asked === 'object' ? asked.has(p.name) : own === null || p.name === own)
       for (const [t, task] of Object.entries(p.config.tasks ?? {}))
         if (!isDefaultBuild(task)) names.add(t)
-  return [...names].sort()
+  return { names: [...names].sort(), inProject: own !== null }
 }
 
 /**