@kaynooo/cli-kit 0.19.0 → 0.21.0

package/src/fzf.ts

@@ -0,0 +1,186 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import process from 'node:process'
+
+export interface Row {
+  hidden: string[]
+  cells: string[]
+}
+
+export interface FzfOptions {
+  prompt: string
+  header?: string
+  // Keys that pick the highlighted row too, telling which one was pressed.
+  expect?: string[]
+  // Called with the hidden fields as `{1}`, `{2}`...
+  preview?: string
+  // How many leading cells are searched, so a word of a description does not outrank the name it was typed for.
+  searched: number
+  // Whole height by default, for a list of a few candidates asked about under the command.
+  height?: string
+  bind?: string[]
+  // How many leading fields are hidden, taken from the first row by default, which a list that starts empty and reloads has none of.
+  hidden?: number
+  // The query comes back too, and an expected key pressed with no row matching still picks, with no hidden fields.
+  query?: boolean
+}
+
+export interface Picked {
+  key: string
+  hidden: string[]
+  query: string
+}
+
+// A row as term lists it with `--list` in place of the fzf window, in the pane's folder: what tmux_pick types back for Enter and for the picker's other keys.
+export interface Listed {
+  label: string
+  hint: string
+  // The words typed after the picker's name to find the same choice again; for a row asking for a text, the ones before it.
+  typed: string
+  // Set for a row asking for a text first, typed after its words: ctrl-n's new branch.
+  asks?: string
+  // The picker's arguments printing the row's preview, its `--show` as fzf calls it.
+  preview?: string[]
+  // ctrl-e leaves the picker's name and these words on the prompt rather than the command they run.
+  editsTyped?: boolean
+  actions?: ListedAction[]
+}
+
+export interface ListedAction {
+  label: string
+  // fzf's name for the key doing it there.
+  key: string
+  typed?: string
+  // The picker run with these arguments, then listed again: ctrl-r's fetch.
+  reload?: string[]
+}
+
+export interface Run {
+  id: string
+  args: string[]
+}
+
+// A word of the command: fixed, an argument given by the user, or the name of one to prompt for; the last two are what a run is remembered with.
+export type Arg = string | { given: string } | { ask: string }
+
+const REMEMBERED = 20
+
+// Every cell but the last padded to its column, one space short of the two between columns since a tab renders as one, see `--tabstop`.
+// Widths are measured without the color codes.
+export function table(rows: Row[]): string[] {
+  const widths = rows[0]?.cells.map((_, index) => Math.max(...rows.map(row => Bun.stringWidth(row.cells[index]!)))) ?? []
+
+  return rows.map(row => [
+    ...row.hidden,
+    ...row.cells.map((cell, index) => (index === row.cells.length - 1 ? cell.trimEnd() : `${cell}${' '.repeat(widths[index]! + 1 - Bun.stringWidth(cell))}`)),
+  ].join('\t'))
+}
+
+export function fzf(rows: Row[], options: FzfOptions): Picked | undefined {
+  const hidden = options.hidden ?? rows[0]?.hidden.length ?? 0
+  const proc = Bun.spawnSync([
+    'fzf',
+    '--prompt',
+    options.prompt,
+    ...options.header === undefined ? [] : ['--header', options.header],
+    ...(options.expect ?? []).length > 0 ? ['--expect', (options.expect ?? []).join(',')] : [],
+    '--ansi',
+    '--reverse',
+    '--height',
+    options.height ?? '100%',
+    '--delimiter',
+    '\t',
+    '--with-nth',
+    `${hidden + 1}..`,
+    '--nth',
+    `1..${options.searched}`,
+    '--tabstop',
+    '1',
+    // The shortest word holding the match wins a tie, `install` before `install-hooks`, where the default length would count the description too.
+    '--tiebreak',
+    'chunk,index',
+    ...options.preview === undefined ? [] : ['--preview', options.preview, '--preview-window', 'down,40%'],
+    ...(options.bind ?? []).flatMap(bind => ['--bind', bind]),
+    ...options.query === true ? ['--print-query'] : [],
+  ], {
+    stdin: new TextEncoder().encode(table(rows).join('\n')),
+    stdout: 'pipe',
+    stderr: 'inherit',
+  })
+
+  return picked(proc.stdout.toString(), hidden, options)
+}
+
+// What fzf printed: the query when asked for, the key when keys are expected, then the line picked.
+export function picked(output: string, hidden: number, options: Pick<FzfOptions, 'expect' | 'query'>): Picked | undefined {
+  const lines = output.split('\n')
+  const query = options.query === true ? lines.shift()! : ''
+  const [key, line] = (options.expect ?? []).length > 0 ? [lines[0]!, lines[1]] : ['', lines[0]]
+
+  if (line !== undefined && line !== '')
+    return { key, hidden: line.split('\t').slice(0, hidden), query }
+
+  return options.query === true && key !== '' ? { key, hidden: [], query } : undefined
+}
+
+// A few candidates, as tall as they need under the command with the preview below them.
+export function heightFor(count: number): string {
+  return String(Math.max(15, Math.ceil((count + 4) / 0.6)))
+}
+
+function historyFile(name: string): string {
+  return join(process.env.XDG_CACHE_HOME ?? join(homedir(), '.cache'), name, 'history.json')
+}
+
+// Keyed by folder, a broken or missing file reading as nothing run yet.
+function history(name: string): Record<string, Run[]> {
+  try {
+    const file = historyFile(name)
+
+    return existsSync(file) ? JSON.parse(readFileSync(file, 'utf-8')) as Record<string, Run[]> : {}
+  }
+  catch {
+    return {}
+  }
+}
+
+export function runs(name: string): Run[] {
+  return history(name)[process.cwd()] ?? []
+}
+
+export function record(name: string, run: Run): void {
+  const all = history(name)
+  const file = historyFile(name)
+
+  all[process.cwd()] = [run, ...(all[process.cwd()] ?? []).filter(earlier => earlier.id !== run.id)].slice(0, REMEMBERED)
+  mkdirSync(dirname(file), { recursive: true })
+  writeFileSync(file, JSON.stringify(all))
+}
+
+// The ones run last come first, most recent at the top, the rest keeping their order.
+export function byRecency<T>(items: T[], previous: Run[], idOf: (item: T) => string): T[] {
+  const rank = new Map(previous.map((run, index) => [run.id, index]))
+  const recent = items.filter(item => rank.has(idOf(item))).sort((a, b) => rank.get(idOf(a))! - rank.get(idOf(b))!)
+
+  return [...recent, ...items.filter(item => !rank.has(idOf(item)))]
+}
+
+function word(arg: Arg): string {
+  if (typeof arg === 'string')
+    return `=${arg}`
+
+  return 'given' in arg ? `+${arg.given}` : `?${arg.ask}`
+}
+
+// The lines `__pick_run` and tmux_pick read: `run`, or `edit` to leave the command on the prompt; the words typed after the picker's name to find the same choice again; the id the run is called back with once the prompts are answered, or nothing; then one line per word of the command, `=fixed`, `+given` or `?name` to prompt for.
+export function emit(mode: 'run' | 'edit', typed: string, recorded: string, command: Arg[]): void {
+  const words = command.map(word)
+
+  console.log([mode, typed, recorded, ...words].join('\n'))
+}
+
+// What `--list` prints, term reading it back.
+export function list(rows: Listed[]): void {
+  console.log(JSON.stringify(rows))
+}

package/src/help.ts

@@ -0,0 +1,91 @@
+import type { Described, Example, Options } from './args'
+import process from 'node:process'
+import { paint } from './style'
+
+// Optional parts of a usage line, `[options]` or `[tag]`, dimmed in the help.
+const OPTIONAL = /\[[^\]]+\]/g
+const USAGE_PREFIX = /^usage:\s*/i
+const FULL_STOP = /\.$/
+
+// `Usage: <usage>`, the usage given with or without its own `usage:`, optional parts dimmed.
+export function usageLine(usage: string, colors = paint(process.stdout)): string {
+  return `${colors.bold('Usage:')} ${usage.replace(USAGE_PREFIX, '').replaceAll(OPTIONAL, part => colors.dim(part))}`
+}
+
+export function helpText(usage: string, options: Options, colors = paint(process.stdout), { examples = [], replaces, exits = [] }: Described = {}): string {
+  return [usageLine(usage, colors), ...replacesRows(replaces, colors), '', colors.bold('Options:'), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join('\n')
+}
+
+// An exit code and what it means.
+export type ExitRow = [code: number | string, meaning: string]
+
+// An `Exits:` block, after a blank line, a line per code with the codes aligned; nothing without one.
+export function exitRows(exits: ExitRow[], colors = paint(process.stdout)): string[] {
+  if (exits.length === 0)
+    return []
+
+  const width = Math.max(...exits.map(([code]) => String(code).length))
+
+  return ['', colors.bold('Exits:'), ...exits.map(([code, meaning]) => `  ${colors.cyan(String(code).padEnd(width))}  ${meaning}`)]
+}
+
+// An `Instead of:` line, after a blank line; nothing without one.
+export function replacesRows(replaces: string | undefined, colors = paint(process.stdout)): string[] {
+  return replaces === undefined ? [] : ['', `${colors.bold('Instead of:')} ${replaces}`]
+}
+
+// What a bin's --help prints under KIT_HELP=json, for `cli list` to read without parsing the text.
+export interface Description {
+  synopsis: string
+  summary: string
+  replaces?: string
+  examples: { line: string, note?: string }[]
+  exits?: { code: number | string, meaning: string }[]
+  // The flags of a command with no subcommands, for a test comparing them with what a README documents.
+  options?: { name: string, short?: string, description?: string }[]
+}
+
+export function wantsHelpJson(env: Record<string, string | undefined> = process.env): boolean {
+  return env.KIT_HELP === 'json'
+}
+
+// The synopsis and the summary a usage's first line splits into at its first `: `, else the first line after the synopses as the summary, with the examples spelled out.
+export function description(usage: string, { examples = [], replaces, exits }: Described = {}, options?: Options): Description {
+  const lines = usage.replace(USAGE_PREFIX, '').split('\n')
+  const first = lines[0]!
+  const colon = first.indexOf(': ')
+  const prose = lines[lines.indexOf('') + 1] ?? ''
+  const fallback = lines.includes('') ? `${prose.charAt(0).toLowerCase()}${prose.slice(1)}`.replace(FULL_STOP, '') : ''
+
+  return {
+    synopsis: colon === -1 ? first : first.slice(0, colon),
+    summary: colon === -1 ? fallback : first.slice(colon + 2),
+    ...replaces === undefined ? {} : { replaces },
+    examples: examples.map(example => typeof example === 'string' ? { line: example } : { line: example[0], note: example[1] }),
+    ...exits === undefined ? {} : { exits: exits.map(([code, meaning]) => ({ code, meaning })) },
+    ...options === undefined ? {} : { options: Object.entries(options).map(([name, { short, description }]) => ({ name, ...short === undefined ? {} : { short }, ...description === undefined ? {} : { description } })) },
+  }
+}
+
+// An `Examples:` section, after a blank line, with a line per example; nothing without one.
+export function exampleRows(examples: Example[], colors = paint(process.stdout)): string[] {
+  if (examples.length === 0)
+    return []
+
+  return ['', colors.bold('Examples:'), ...examples.map(example => typeof example === 'string' ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)]
+}
+
+// A line per option, `-n, --times <value>  how many`, aligned on the visible text.
+export function optionRows(options: Options, colors = paint(process.stdout)): string[] {
+  const rows = Object.entries(options).map(([name, option]) => {
+    const short = option.short === undefined ? '    ' : `${colors.cyan(`-${option.short}`)}, `
+    const named = option.choices === undefined ? '<value>' : `<${option.choices.join('|')}>`
+    const placeholder = option.optional === undefined ? named : `[${named}]`
+    const value = option.type === 'string' ? ` ${colors.dim(placeholder)}` : ''
+
+    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === 'string' ? placeholder.length + 1 : 0), description: option.description ?? '' }
+  })
+  const width = Math.max(0, ...rows.map(row => row.width))
+
+  return rows.map(row => row.description === '' ? `  ${row.flag}` : `  ${row.flag}${' '.repeat(width - row.width)}  ${colors.dim(row.description)}`)
+}

package/src/index.ts

@@ -1,7 +1,9 @@
+export * from './advisory'
 export * from './args'
 export * from './chart'
 export * from './ci'
 export * from './cli'
+export * from './compose'
 export * from './config'
 export * from './format'
 export * from './git'
@@ -10,6 +12,9 @@ export * from './logs'
 export * from './process'
 export * from './secrets'
 export * from './sessions'
+export * from './size'
 export * from './style'
 export * from './text'
 export * from './tool'
+export * from './usage'
+export * from './user-config'

package/src/input.ts

@@ -0,0 +1,64 @@
+import { fstatSync } from 'node:fs'
+import process from 'node:process'
+import { badUsage, fail } from './args'
+
+const WHOLE = /^\d+$/
+
+// A name written `<run id>` is a positional and is printed as is, any other is an option printed `--name`.
+export function wholeNumber(value: string | undefined, name: string, fallback: number, min = 1): number {
+  if (value === undefined)
+    return fallback
+
+  const number = Number(value)
+
+  if (!WHOLE.test(value) || !Number.isSafeInteger(number) || number < min)
+    badUsage(`${name.startsWith('<') ? name : `--${name}`} takes a whole number from ${min}, not ${value}`)
+
+  return number
+}
+
+const DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/
+const UNIT_MS = { ms: 1, s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 } as const
+
+// A duration such as `500ms`, `90s`, `5m`, `1h` or `7d` in milliseconds, a bare number counting in `unit`.
+export function duration(value: string | undefined, name: string, fallback: number, unit: 's' | 'm' | 'h' = 's'): number {
+  if (value === undefined)
+    return fallback
+
+  const match = DURATION.exec(value.trim())
+  const ms = match === null ? 0 : Number(match[1]) * UNIT_MS[(match[2] ?? unit) as keyof typeof UNIT_MS]
+
+  if (ms < 1)
+    badUsage(`--${name} takes a duration such as 30s, 5m, 1h or 7d, not ${value}`)
+
+  return ms
+}
+
+// Whether stdin is a pipe or a file to read, rather than a terminal or /dev/null that would leave a command waiting or reading nothing.
+export function isStdinPiped(): boolean {
+  const stat = fstatSync(0)
+
+  return stat.isFIFO() || stat.isFile()
+}
+
+export interface InputSettings {
+  // What to say when stdin is a terminal, as nothing is piped.
+  noStdin?: string
+}
+
+// Text from a file, or from stdin when the path is `-`. A missing file or a stdin left on the terminal ends the command.
+export async function readInput(path: string, { noStdin = 'nothing is piped on stdin' }: InputSettings = {}): Promise<string> {
+  if (path === '-') {
+    if (process.stdin.isTTY)
+      fail(noStdin)
+
+    return Bun.stdin.text()
+  }
+
+  const file = Bun.file(path)
+
+  if (!await file.exists())
+    fail(`no file ${path}`)
+
+  return file.text()
+}

package/src/shell.ts

@@ -1,6 +1,6 @@
 // `text` is the piece as written, `command` the same less its heredoc bodies and comments, which are data and never commands; `separator` is what ends it (`|`, `&&`, `;`, a newline...), empty for the last; `expanded` holds the bodies of its unquoted heredocs, where the shell still runs `$(...)`, and `heredocs` those of all its heredocs.
 export interface Piece { text: string, start: number, end: number, command: string, separator: string, expanded: string, heredocs: string[] }
-export interface Invocation { program: string, args: string[], assignments: string[], isWrapped: boolean }
+export interface Invocation { program: string, args: string[], assignments: string[], isWrapped: boolean, strings: string[] }
 
 const SEPARATORS = new Set(['\n', ';', '|'])
 const PLAIN_BREAKERS = new Set(['<', '>', '(', ')', '&', '|'])
@@ -30,18 +30,30 @@ const OCTAL = /^[0-7]{1,3}/
 const KEYWORDS = new Set(['then', 'do', 'else', 'if', 'elif', 'while', 'until', '!', '{', '}'])
 const MAX_DEPTH = 8
 const MAX_BRACES = 256
+
 // Programs reading a command string with `-c`.
-const SHELLS = new Set(['sh', 'bash', 'zsh', 'dash', 'ash', 'ksh'])
-const COMMAND_STRING_PROGRAMS = new Set([...SHELLS, 'su', 'runuser'])
+export const SHELLS = new Set(['sh', 'bash', 'zsh', 'dash', 'ash', 'ksh', 'fish', 'csh', 'tcsh', 'nu', 'xonsh', 'elvish', 'pwsh', 'powershell'])
+// Programs that take their command string past other operands, so every word is scanned for the option.
+const SCANNED_PROGRAMS = new Set(['su', 'runuser', 'flock'])
+const COMMAND_STRING_PROGRAMS = new Set([...SHELLS, ...SCANNED_PROGRAMS])
+// PowerShell's `-Command`, which it accepts abbreviated to any prefix.
+const POWERSHELL_COMMAND = /^-c(?:o(?:m(?:m(?:a(?:nd?)?)?)?)?)?$/i
+const POWERSHELL = new Set(['pwsh', 'powershell'])
+const FUNCTION_DEFINITION = /^[\w.:-]+\(\)\{?$/
+const FUNCTION_NAME = /^[\w.:-]+$/
 const SHELL_VALUE_OPTIONS = new Set(['-o', '-O', '--rcfile', '--init-file'])
+const FISH_VALUE_OPTIONS = new Set(['-C', '--init-command'])
+// A `let` builtin, whose `<<` is a shift.
+const LET_PIECE = /^\s*let\s/
 const PRINTERS = new Set(['echo', 'printf'])
 const FIND_EXEC = new Set(['-exec', '-execdir', '-ok', '-okdir'])
 
 // Programs that run the command following them, which is the one that counts, with the options taking a value and the operands before that command.
-interface WrapperSpec { short: string, long: readonly string[], operands: number }
+interface WrapperSpec { short: string, long: readonly string[], operands: number, runsString: boolean }
 
-function wrapper(short = '', long: readonly string[] = [], operands = 0): WrapperSpec {
-  return { short, long, operands }
+// `runsString` for a wrapper that hands its command to a shell, so a quoted `'git stash'` is a command line.
+function wrapper(short = '', long: readonly string[] = [], operands = 0, runsString = false): WrapperSpec {
+  return { short, long, operands, runsString }
 }
 
 const WRAPPERS = new Map<string, WrapperSpec>([
@@ -60,6 +72,11 @@ const WRAPPERS = new Map<string, WrapperSpec>([
   ['ionice', wrapper('cnpPu', ['--class', '--classdata', '--pid', '--pgid', '--uid'])],
   ['stdbuf', wrapper('ioe', ['--input', '--output', '--error'])],
   ['chroot', wrapper('', ['--userspec', '--groups'], 1)],
+  ['watch', wrapper('n', ['--interval'], 0, true)],
+  ['flock', wrapper('wE', ['--timeout', '--conflict-exit-code'], 1)],
+  ['parallel', wrapper('jnNSaIPlLdTsC', ['--jobs', '--max-args', '--max-replace-args', '--sshlogin', '--arg-file', '--delimiter', '--colsep'], 0, true)],
+  ['unbuffer', wrapper()],
+  ['systemd-run', wrapper('puEMH', ['--property', '--unit', '--description', '--slice', '--setenv', '--machine', '--host', '--uid', '--gid', '--working-directory', '--nice', '--service-type'])],
   ['xargs', wrapper('IndsEaPL', ['--max-args', '--max-procs', '--max-chars', '--delimiter', '--arg-file', '--eof', '--max-lines', '--process-slot-var'])],
 ])
 
@@ -162,6 +179,15 @@ export function splitCommand(command: string): Piece[] {
       continue
     }
 
+    // The legacy arithmetic `$[...]` is read whole, like `$((...))`.
+    if (char === '$' && command[i + 1] === '[') {
+      const close = command.indexOf(']', i)
+
+      i = close === -1 ? command.length : close
+
+      continue
+    }
+
     // A backquoted body is read whole, as its own separators split nothing of the command around it.
     if (char === '`') {
       i = closingBackquote(command, i)
@@ -169,6 +195,13 @@ export function splitCommand(command: string): Piece[] {
       continue
     }
 
+    // Arithmetic is read whole: its `<<` shifts, it opens no heredoc.
+    if (command.startsWith('((', char === '$' ? i + 1 : i) && (char === '$' || startsComment(command, i))) {
+      i = closingParen(command, char === '$' ? i + 1 : i)
+
+      continue
+    }
+
     if (char === '#' && startsComment(command, i)) {
       const newline = command.indexOf('\n', i)
       const end = newline === -1 ? command.length : newline
@@ -179,7 +212,7 @@ export function splitCommand(command: string): Piece[] {
       continue
     }
 
-    const heredoc = char === '<' && command[i + 1] === '<' && command[i + 2] !== '<' ? HEREDOC.exec(command.slice(i)) : null
+    const heredoc = char === '<' && command[i + 1] === '<' && command[i + 2] !== '<' && !LET_PIECE.test(command.slice(start, i)) ? HEREDOC.exec(command.slice(i)) : null
 
     if (heredoc) {
       heredocs.push({ word: heredoc[2] ?? heredoc[3] ?? heredoc[4] ?? '', stripsTabs: heredoc[1] === '-', isQuoted: heredoc[4] === undefined })
@@ -545,13 +578,29 @@ function skipOptions(tokens: string[], spec: WrapperSpec): void {
 export function parseCommand(text: string): Invocation {
   const tokens = tokenize(text)
   const assignments: string[] = []
+  const strings: string[] = []
   let isWrapped = false
 
   for (;;) {
     const first = tokens[0] ?? ''
     const spec = WRAPPERS.get(first.split('/').pop() ?? '')
 
-    if (OPENERS.test(first)) {
+    if (first === 'function' && tokens.length > 1) {
+      isWrapped = true
+      tokens.splice(0, 2)
+
+      if (tokens[0] === '()')
+        tokens.shift()
+    }
+    else if (FUNCTION_DEFINITION.test(first)) {
+      isWrapped = true
+      tokens.shift()
+    }
+    else if (tokens[1] === '()' && FUNCTION_NAME.test(first)) {
+      isWrapped = true
+      tokens.splice(0, 2)
+    }
+    else if (OPENERS.test(first)) {
       isWrapped = true
       const rest = first.replace(OPENERS, '')
 
@@ -580,6 +629,9 @@ export function parseCommand(text: string): Invocation {
       isWrapped = true
       tokens.shift()
       skipOptions(tokens, spec)
+
+      if (spec.runsString && WHITESPACE.test(tokens[0] ?? ''))
+        strings.push(tokens[0] ?? '')
     }
     else {
       break
@@ -596,7 +648,7 @@ export function parseCommand(text: string): Invocation {
 
   const [program = '', ...args] = tokens
 
-  return { program: program.split('/').pop() ?? '', args, assignments, isWrapped }
+  return { program: program.split('/').pop() ?? '', args, assignments, isWrapped, strings }
 }
 
 // A word as a POSIX shell or zsh reads it back unchanged: left bare when it holds nothing the shell would act on (zsh expands a leading `=`), else single-quoted.
@@ -618,7 +670,8 @@ function commandStrings(tokens: readonly string[]): string[] {
     if (!COMMAND_STRING_PROGRAMS.has(name))
       continue
 
-    const isUser = name === 'su' || name === 'runuser'
+    const isScanned = SCANNED_PROGRAMS.has(name)
+    const isPowershell = POWERSHELL.has(name)
     let isValue = false
 
     for (let j = i + 1; j < tokens.length; j++) {
@@ -630,25 +683,27 @@ function commandStrings(tokens: readonly string[]): string[] {
         continue
       }
 
-      if (SHELL_VALUE_OPTIONS.has(option)) {
+      if (SHELL_VALUE_OPTIONS.has(option) || (name === 'fish' && FISH_VALUE_OPTIONS.has(option))) {
         isValue = true
 
         continue
       }
 
-      if (option.startsWith('--command=')) {
-        found.push(option.slice('--command='.length))
+      if (option.startsWith('--command=') || option.startsWith('--commands=')) {
+        found.push(option.slice(option.indexOf('=') + 1))
 
         break
       }
 
-      if (option === '--command' || (!option.startsWith('--') && option.startsWith('-') && option.slice(1).includes('c'))) {
-        found.push(tokens[j + 1] ?? '')
+      const isCommandOption = isPowershell ? POWERSHELL_COMMAND.test(option) : !option.startsWith('--') && option.startsWith('-') && option.slice(1).includes('c')
+
+      if (option === '--command' || option === '--commands' || isCommandOption) {
+        found.push(isPowershell ? tokens.slice(j + 1).join(' ') : (tokens[j + 1] ?? ''))
 
         break
       }
 
-      if (!option.startsWith('-') && !isUser)
+      if (!option.startsWith('-') && !isScanned)
         break
     }
   }
@@ -695,8 +750,8 @@ function findExecs(args: readonly string[]): string[] {
 // The commands a piece makes a shell run besides its own: `sh -c` strings, `eval`, `find -exec`, and what is fed to a shell reading its input, heredocs, here-strings and an `echo` piped in.
 function nestedCommands(piece: Piece, previous: Piece | undefined): string[] {
   const tokens = tokenize(piece.command)
-  const { program, args } = parseCommand(piece.command)
-  const found = commandStrings(tokens)
+  const { program, args, strings } = parseCommand(piece.command)
+  const found = [...commandStrings(tokens), ...strings]
 
   if (program === 'eval')
     found.push(args.join(' '))

package/src/size.ts

@@ -0,0 +1,14 @@
+const SIZE = /^(\d+(?:\.\d+)?)\s*([kmgt]?)i?b?$/i
+const POWERS: Record<string, number> = { '': 0, 'k': 1, 'm': 2, 'g': 3, 't': 4 }
+
+// A size such as `500M`, `1.5G` or `800kb` in bytes, counting in powers of 1024; a bare number counts `bareUnit` bytes (1 for bytes, 1024 ** 2 for megabytes). Undefined when it is none.
+export function parseSize(text: string, bareUnit = 1): number | undefined {
+  const match = SIZE.exec(text.trim())
+
+  if (match === null)
+    return undefined
+
+  const suffix = match[2]!.toLowerCase()
+
+  return Math.round(Number(match[1]) * (suffix === '' ? bareUnit : 1024 ** POWERS[suffix]!))
+}

package/src/tool.ts

@@ -61,11 +61,14 @@ export async function runTool(label: string, argv: string[], { timeoutMs, cwd, o
   if (ran.timedOut)
     throw new Error(`${label}: no answer in ${formatDuration(timeoutMs ?? 0)}`)
 
-  const decoder = new TextDecoder()
+  const decoders = { stdout: new TextDecoder(), stderr: new TextDecoder() }
   const streams = { stdout: '', stderr: '' }
 
   for (const { stream, data } of ran.chunks)
-    streams[stream] += decoder.decode(data, { stream: true })
+    streams[stream] += decoders[stream].decode(data, { stream: true })
+
+  streams.stdout += decoders.stdout.decode()
+  streams.stderr += decoders.stderr.decode()
 
   return { code: ran.code, ...streams }
 }