@vzn/vx 0.0.635 → 0.0.637

package/src/cli/last.ts

@@ -9,11 +9,14 @@ import { Cache } from '../cache/index.js'
 import { formatBytes } from './format.js'
 import { flagHint, formatValue, seeHelp } from './help.js'
 import {
+  currentBranch,
   exitSignal,
+  type FailureMode,
   getInvocation,
   getRun,
   type InvocationDetail,
   listInvocations,
+  LocalHistoryProvider,
   outcomeWord,
   type RunSummaryRow,
   resolveRunId,
@@ -21,7 +24,7 @@ import {
   shortRunId,
   taskLog,
 } from '../orchestrator/index.js'
-import { formatElapsed, UserError } from '../util/index.js'
+import { formatElapsed, splitTaskId, UserError } from '../util/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import { cliCacheDir, parseCacheDirFlag } from './workspace-config.js'
 
@@ -33,6 +36,12 @@ interface LastArgs {
   format: 'pretty' | 'json'
   /** `--log <task>`: that task's output in the run, not the run's summary. */
   log?: string
+  /** `--stats`: per-task numbers over the history window, not a run. */
+  stats?: boolean
+  /** `--stats`' positional: a task id, or a task name in every project. */
+  task?: string
+  /** `--branch`: the branch `--stats` forecasts from, as a run's `--branch`. */
+  branch?: string
   /** `--cache-dir`: read the history a run with the same flag wrote. */
   cacheDir?: string
   error?: string
@@ -46,6 +55,8 @@ const RUN_ID_SHAPE = /^[0-9a-f]{8}(?:-|$)/i
 
 export function parseLastArgs(args: readonly string[]): LastArgs {
   const out: LastArgs = { format: 'pretty' }
+  // `vx last app#build --log`: a bare --log takes the positional as its task.
+  let bareLog = false
   for (let i = 0; i < args.length; i++) {
     const a = args[i]!
     if (a === '--list' || a.startsWith('--list=')) {
@@ -76,9 +87,30 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
       out.failed = true
       continue
     }
-    if (a === '--log' || a.startsWith('--log=')) {
-      const v = a === '--log' ? args[++i] : a.slice('--log='.length)
-      if (v === undefined || v === '' || v.startsWith('-')) {
+    if (a === '--stats') {
+      out.stats = true
+      continue
+    }
+    if (a === '--branch' || a.startsWith('--branch=')) {
+      const v = a === '--branch' ? args[++i] : a.slice('--branch='.length)
+      if (v === undefined || v === '' || (a === '--branch' && v.startsWith('-'))) {
+        return { ...out, error: `--branch requires a branch name${seeHelp('last')}` }
+      }
+      out.branch = v
+      continue
+    }
+    if (a === '--log') {
+      const v = args[i + 1]
+      if (v === undefined || v.startsWith('-')) bareLog = true
+      else {
+        out.log = v
+        i++
+      }
+      continue
+    }
+    if (a.startsWith('--log=')) {
+      const v = a.slice('--log='.length)
+      if (v === '') {
         return { ...out, error: `--log requires a task id, like app#build${seeHelp('last')}` }
       }
       out.log = v
@@ -103,6 +135,27 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
       return { ...out, error: `unexpected argument: ${a}${seeHelp('last')}` }
     out.runId = a
   }
+  if (bareLog) {
+    if (out.runId === undefined) {
+      return { ...out, error: `--log requires a task id, like app#build${seeHelp('last')}` }
+    }
+    out.log = out.runId
+    delete out.runId
+  }
+  if (out.stats === true) {
+    if (out.list !== undefined || out.failed === true || out.log !== undefined) {
+      return {
+        ...out,
+        error: `--stats does not combine with --list, --failed or --log${seeHelp('last')}`,
+      }
+    }
+    if (out.runId !== undefined) out.task = out.runId
+    delete out.runId
+    return out
+  }
+  if (out.branch !== undefined) {
+    return { ...out, error: `--branch combines only with --stats${seeHelp('last')}` }
+  }
   // One run's replay or a list of runs, not both: the id was dropped.
   // Beside --list, a word no run id could be is just an extra one.
   if (out.runId !== undefined && out.list !== undefined && !RUN_ID_SHAPE.test(out.runId)) {
@@ -137,6 +190,88 @@ function failedInvocations(db: Database, limit: number): InvocationDetail[] {
   return ids.map((r) => getInvocation(db, r.run_id)).filter((i) => i !== null)
 }
 
+/** One task's numbers over the window, every key present (`null` where unknown). */
+export interface TaskStats {
+  taskId: string
+  runs: number
+  p50DurationMs: number | null
+  p99DurationMs: number | null
+  successRate: number
+  hitRate: number
+  failureMode: FailureMode
+  maxPeakRssBytes: number | null
+  maxCpuParallelism: number | null
+}
+
+/**
+ * `--stats`: what the scheduler and `--dry` learn from history, per task,
+ * over the same window (`LocalHistoryProvider`), with the p50 a run on
+ * `branch` forecasts.
+ */
+async function printStats(
+  db: Database,
+  target: string | undefined,
+  format: 'pretty' | 'json',
+  branch: string | null,
+): Promise<number> {
+  const provider = new LocalHistoryProvider(db, undefined, branch)
+  const matches = (id: string): boolean =>
+    target === undefined || (target.includes('#') ? id === target : splitTaskId(id)[1] === target)
+  const stats: TaskStats[] = [...(await provider.loadAll())]
+    .filter(([id]) => matches(id))
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([taskId, h]) => ({
+      taskId,
+      runs: h.runs,
+      p50DurationMs: h.p50DurationMs ?? null,
+      p99DurationMs: h.p99DurationMs ?? null,
+      successRate: h.successRate,
+      hitRate: h.hitRate,
+      failureMode: h.failureMode,
+      maxPeakRssBytes: h.maxPeakRssBytes ?? null,
+      maxCpuParallelism: h.maxCpuParallelism ?? null,
+    }))
+  if (stats.length === 0 && target !== undefined) {
+    throw new UserError(
+      `vx last: no recorded run of ${target} in the last ${provider.recent} runs`,
+      'VX_E_NO_HISTORY',
+    )
+  }
+  if (format === 'json') {
+    process.stdout.write(`${JSON.stringify({ window: provider.recent, branch, stats })}\n`)
+    return 0
+  }
+  if (stats.length === 0) {
+    process.stdout.write('no recorded runs\n')
+    return 0
+  }
+  const pct = (r: number): string => `${Math.round(r * 100)}%`
+  const ms = (v: number | null): string => (v === null ? '-' : fmtMs(v))
+  const rows = [
+    ['task', 'runs', 'p50', 'p99', 'pass', 'hit', 'failure mode', 'peak rss', 'cpu'],
+    ...stats.map((s) => [
+      s.taskId,
+      String(s.runs),
+      ms(s.p50DurationMs),
+      ms(s.p99DurationMs),
+      pct(s.successRate),
+      pct(s.hitRate),
+      s.failureMode,
+      s.maxPeakRssBytes === null ? '-' : formatBytes(s.maxPeakRssBytes),
+      s.maxCpuParallelism === null ? '-' : `${s.maxCpuParallelism.toFixed(1)}×`,
+    ]),
+  ]
+  const widths = rows[0]!.map((_, c) => Math.max(...rows.map((r) => r[c]!.length)))
+  const lines = rows.map((r) =>
+    r
+      .map((cell, c) => cell.padEnd(widths[c]!))
+      .join('  ')
+      .trimEnd(),
+  )
+  process.stdout.write(`${lines.join('\n')}\n`)
+  return 0
+}
+
 const fmtWhen = (ms: number): string => new Date(ms).toISOString()
 
 const fmtMs = (ms: number): string => formatElapsed(ms, true)
@@ -312,6 +447,11 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
     // nothing, while `--list --failed` past green runs said there were none.
     const noRuns = (): boolean => listInvocations(db, { limit: 1 }).length === 0
 
+    if (parsed.stats === true) {
+      const branch = currentBranch(root, undefined, parsed.branch)
+      return await printStats(db, parsed.task, parsed.format, branch)
+    }
+
     if (parsed.log !== undefined) {
       const runId =
         parsed.runId === undefined
@@ -388,6 +528,7 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
           ? t
           : {
               ...t,
+              ...(f.inputMoved !== undefined ? { inputMoved: f.inputMoved } : {}),
               output: f.output,
               locations: f.locations,
               ...(f.sandboxFix !== undefined ? { sandboxFix: f.sandboxFix } : {}),