effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/unstable/cli/internal/completions/bash.ts

@@ -27,45 +27,97 @@ const flagNamesForWordlist = (flag: Completions.FlagDescriptor): Array<string> =
   return names
 }
 
-/**
- * Build an associative array mapping each flag form to a group index.
- * At completion time, if any form in a group appears in COMP_WORDS,
- * all forms in that group are removed from the candidate list.
- */
+/** Emit a Bash 3.2-compatible used-flag filter. */
 const buildFlagGroupDeclarations = (
   flags: ReadonlyArray<Completions.FlagDescriptor>,
   lines: Array<string>
 ): void => {
   if (flags.length === 0) return
-  lines.push(`  # Build used-flag filter`)
-  lines.push(`  local -A _flag_groups`)
-  let groupIdx = 0
-  for (const flag of flags) {
-    const forms = flagNamesForWordlist(flag)
-    for (const form of forms) {
-      lines.push(`  _flag_groups[${form}]=${groupIdx}`)
-    }
-    groupIdx++
-  }
-  lines.push(`  local -A _used_groups`)
+  const groups = flags.map(flagNamesForWordlist)
+  lines.push(`  local ${groups.map((_, index) => `_used_${index}=""`).join(" ")}`)
   lines.push(`  for ((i = 1; i < cword; i++)); do`)
-  lines.push(`    local _g="\${_flag_groups[\${words[i]}]:-}"`)
-  lines.push(`    [[ -n "$_g" ]] && _used_groups[$_g]=1`)
+  lines.push(`    case "\${words[i]%%=*}" in`)
+  groups.forEach((forms, index) => {
+    lines.push(`      ${forms.join("|")}) _used_${index}=1 ;;`)
+  })
+  lines.push(`    esac`)
   lines.push(`  done`)
   lines.push(`  local _filtered_flags=""`)
-  lines.push(`  for _f in ${flags.flatMap(flagNamesForWordlist).join(" ")}; do`)
-  lines.push(`    local _g="\${_flag_groups[$_f]:-}"`)
-  lines.push(`    [[ -z "$_g" || -z "\${_used_groups[$_g]:-}" ]] && _filtered_flags+=" $_f"`)
+  groups.forEach((forms, index) => {
+    lines.push(`  [[ -n "$_used_${index}" ]] || _filtered_flags+=" ${forms.join(" ")}"`)
+  })
+  lines.push(``)
+}
+
+/**
+ * Complete choices without `compgen -W`, which reparses quoted values. Escape
+ * only the portion readline replaces for the active quote context.
+ *
+ * `!` cannot be escaped inside a user-opened double quote without changing the
+ * resulting argument.
+ */
+const choicesHelper = (helperName: string, lines: Array<string>): void => {
+  lines.push(`${helperName}()`)
+  lines.push(`{`)
+  lines.push(`  local _cur="$1" _word="$2"; shift 2`)
+  lines.push(``)
+  lines.push(`  local _head="\${_cur%"$_word"}"`)
+  lines.push(`  local _open=""`)
+  lines.push(`  case "$_head" in`)
+  lines.push(`    *\\') _open="'" ;;`)
+  lines.push(`    *\\") _open='"' ;;`)
+  lines.push(`  esac`)
+  lines.push(``)
+  lines.push(`  local _prefix="$_cur" _committed="$_head"`)
+  // Quoting these substitutions breaks quote matching on Bash 3.2.
+  lines.push(`  _prefix=\${_prefix//\\\\/}; _prefix=\${_prefix//\\"/}; _prefix=\${_prefix//\\'/}`)
+  lines.push(`  _committed=\${_committed//\\\\/}; _committed=\${_committed//\\"/}; _committed=\${_committed//\\'/}`)
+  lines.push(``)
+  lines.push(`  COMPREPLY=()`)
+  lines.push(`  local _choice _rest _match`)
+  lines.push(`  for _choice in "$@"; do`)
+  lines.push(`    [[ "$_choice" == "$_prefix"* ]] || continue`)
+  lines.push(`    _rest="\${_choice#"$_committed"}"`)
+  lines.push(`    case "$_open" in`)
+  lines.push(`      "'")`)
+  lines.push(`        if [[ "$_head" == "'" ]]; then`)
+  // Use a shell splice for a quote opened at the start of the word.
+  lines.push(`          _match=\${_rest//\\'/\\'\\\\\\'\\'}`)
+  lines.push(`        else`)
+  // A mid-word single-quote context cannot contain another single quote.
+  lines.push(`          [[ "$_rest" == *\\'* ]] && continue`)
+  lines.push(`          _match="$_rest"`)
+  lines.push(`        fi`)
+  lines.push(`        ;;`)
+  lines.push(`      '"')`)
+  lines.push(`        _match="\${_rest//\\\\/\\\\\\\\}"`)
+  lines.push(`        _match="\${_match//\\$/\\\\$}"`)
+  lines.push("        _match=\"${_match//\\`/\\\\\\`}\"")
+  lines.push(`        _match="\${_match//\\"/\\\\\\"}"`)
+  lines.push(`        ;;`)
+  lines.push(`      *)`)
+  lines.push(`        printf -v _match '%q' "$_rest"`)
+  // Bash 3.2 leaves a leading tilde unescaped.
+  lines.push(`        [[ -z "$_head" && "$_match" == '~'* ]] && _match="\\\\$_match"`)
+  lines.push(`        ;;`)
+  lines.push(`    esac`)
+  // Readline omits a closing quote already present in the match.
+  lines.push(`    [[ -n "$_open" && "$_match" == *"$_open" ]] && _match+="$_open"`)
+  lines.push(`    COMPREPLY+=("$_match")`)
   lines.push(`  done`)
+  lines.push(`}`)
   lines.push(``)
 }
 
-const flagValueCompletion = (type: Completions.FlagType): string | undefined => {
+const choiceCompletion = (helperName: string, values: ReadonlyArray<string>): string =>
+  `${helperName} "$cur" "$_comp_word" ${values.map((value) => `'${escapeForBash(value)}'`).join(" ")}`
+
+const flagValueCompletion = (type: Completions.FlagType, helperName: string): string | undefined => {
   switch (type._tag) {
     case "Boolean":
       return undefined
     case "Choice":
-      return `COMPREPLY=( $(compgen -W '${type.values.join(" ")}' -- "$cur") )`
+      return choiceCompletion(helperName, type.values)
     case "Path":
       if (type.pathType === "directory") return `COMPREPLY=( $(compgen -d -- "$cur") )`
       return `COMPREPLY=( $(compgen -f -- "$cur") )`
@@ -74,10 +126,10 @@ const flagValueCompletion = (type: Completions.FlagType): string | undefined =>
   }
 }
 
-const argCompletion = (type: Completions.ArgumentType): string | undefined => {
+const argCompletion = (type: Completions.ArgumentType, helperName: string): string | undefined => {
   switch (type._tag) {
     case "Choice":
-      return `COMPREPLY=( $(compgen -W '${type.values.join(" ")}' -- "$cur") )`
+      return choiceCompletion(helperName, type.values)
     case "Path":
       if (type.pathType === "directory") return `COMPREPLY=( $(compgen -d -- "$cur") )`
       return `COMPREPLY=( $(compgen -f -- "$cur") )`
@@ -93,7 +145,8 @@ const argCompletion = (type: Completions.ArgumentType): string | undefined => {
 const generateFunction = (
   descriptor: Completions.CommandDescriptor,
   parentPath: ReadonlyArray<string>,
-  lines: Array<string>
+  lines: Array<string>,
+  helperName: string
 ): void => {
   const currentPath = [...parentPath, descriptor.name]
   const funcName = `_${currentPath.map(sanitizeFunctionName).join("_")}`
@@ -102,7 +155,12 @@ const generateFunction = (
   lines.push(`{`)
   lines.push(`  local cur prev words cword i`)
   lines.push(parentPath.length === 0 ? `  local _command_index=0` : `  local _command_index="$1"`)
-  lines.push(`  _init_completion || return`)
+  // Keep values containing COMP_WORDBREAKS characters in one word.
+  lines.push(`  _init_completion -n "$COMP_WORDBREAKS" || return`)
+  if (parentPath.length === 0) {
+    // Subcommand functions inherit this through Bash's dynamic scope.
+    lines.push(`  local _comp_word="$2"`)
+  }
   lines.push(``)
 
   // Build flag-value dispatch
@@ -115,7 +173,7 @@ const generateFunction = (
       for (const alias of flag.aliases) {
         longNames.push(alias.length === 1 ? `-${alias}` : `--${alias}`)
       }
-      const completion = flagValueCompletion(flag.type)
+      const completion = flagValueCompletion(flag.type, helperName)
       if (completion) {
         lines.push(`    ${longNames.join("|")})`)
         lines.push(`      ${completion}`)
@@ -171,7 +229,7 @@ const generateFunction = (
 
   // Positional argument completion
   const argsWithCompletions = descriptor.arguments.flatMap((argument, index) => {
-    const completion = argCompletion(argument.type)
+    const completion = argCompletion(argument.type, helperName)
     return completion === undefined ? [] : [{ argument, completion, index }]
   })
   if (argsWithCompletions.length > 0) {
@@ -227,7 +285,7 @@ const generateFunction = (
 
   // Recurse into subcommands
   for (const sub of descriptor.subcommands) {
-    generateFunction(sub, currentPath, lines)
+    generateFunction(sub, currentPath, lines, helperName)
   }
 }
 
@@ -238,6 +296,8 @@ export const generate = (
 ): string => {
   const lines: Array<string> = []
   const safeName = sanitizeFunctionName(executableName)
+  // Sanitized command names cannot contain `-`.
+  const helperName = `_${safeName}--choices`
 
   lines.push(`###-begin-${escapeForBash(executableName)}-completions-###`)
   lines.push(`#`)
@@ -248,22 +308,37 @@ export const generate = (
   lines.push(`#`)
   lines.push(``)
 
-  // Inline minimal _init_completion fallback for environments without
-  // bash-completion installed. The real _init_completion handles edge cases
-  // (= in options, redirections, etc.) but this covers the common path.
+  // Fallback for environments without bash-completion. Preserve word-break
+  // characters inside values.
   lines.push(`if ! type _init_completion &>/dev/null; then`)
   lines.push(`  _init_completion()`)
   lines.push(`  {`)
   lines.push(`    COMPREPLY=()`)
-  lines.push(`    cur="\${COMP_WORDS[COMP_CWORD]}"`)
-  lines.push(`    prev="\${COMP_WORDS[COMP_CWORD-1]}"`)
-  lines.push(`    words=("\${COMP_WORDS[@]}")`)
-  lines.push(`    cword=$COMP_CWORD`)
+  lines.push(`    local _i _j=0 _piece _line="$COMP_LINE"`)
+  lines.push(`    words=("\${COMP_WORDS[0]}")`)
+  lines.push(`    cword=0`)
+  lines.push(`    _line="\${_line#*"\${COMP_WORDS[0]}"}"`)
+  lines.push(`    for ((_i = 1; _i < \${#COMP_WORDS[@]}; _i++)); do`)
+  lines.push(`      _piece="\${COMP_WORDS[_i]}"`)
+  lines.push(`      if [[ "$_line" == [[:blank:]]* ]]; then`)
+  lines.push(`        ((_j++))`)
+  lines.push(`        words[_j]="$_piece"`)
+  lines.push(`      else`)
+  lines.push(`        words[_j]="\${words[_j]}$_piece"`)
+  lines.push(`      fi`)
+  lines.push(`      ((_i == COMP_CWORD)) && cword=$_j`)
+  lines.push(`      _line="\${_line#*"$_piece"}"`)
+  lines.push(`    done`)
+  lines.push(`    cur="\${words[cword]}"`)
+  lines.push(`    prev=""`)
+  lines.push(`    ((cword > 0)) && prev="\${words[cword-1]}"`)
+  lines.push(`    return 0`)
   lines.push(`  }`)
   lines.push(`fi`)
   lines.push(``)
 
-  generateFunction(descriptor, [], lines)
+  choicesHelper(helperName, lines)
+  generateFunction(descriptor, [], lines, helperName)
 
   lines.push(`complete -F _${safeName} ${escapeForBash(executableName)}`)
   lines.push(`###-end-${escapeForBash(executableName)}-completions-###`)

package/src/unstable/cli/internal/completions/descriptor.ts

@@ -20,10 +20,10 @@ const toFlagType = (single: Param.Single<"flag", unknown>): Completions.FlagType
   switch (tag) {
     case "Boolean":
       return { _tag: "Boolean" }
-    case "Integer":
-      return { _tag: "Integer" }
-    case "Float":
-      return { _tag: "Float" }
+    case "Int":
+      return { _tag: "Int" }
+    case "Finite":
+      return { _tag: "Finite" }
     case "Date":
       return { _tag: "Date" }
     case "Choice": {
@@ -44,10 +44,10 @@ const toFlagType = (single: Param.Single<"flag", unknown>): Completions.FlagType
 const toArgumentType = (single: Param.Single<"argument", unknown>): Completions.ArgumentType => {
   const tag = single.primitiveType._tag
   switch (tag) {
-    case "Integer":
-      return { _tag: "Integer" }
-    case "Float":
-      return { _tag: "Float" }
+    case "Int":
+      return { _tag: "Int" }
+    case "Finite":
+      return { _tag: "Finite" }
     case "Date":
       return { _tag: "Date" }
     case "Choice": {
@@ -70,18 +70,25 @@ const toArgumentType = (single: Param.Single<"argument", unknown>): Completions.
 // ---------------------------------------------------------------------------
 
 /** @internal */
-export const fromCommand = (cmd: Command.Any): Completions.CommandDescriptor => {
+export const fromCommand = (
+  cmd: Command.Any,
+  inheritedFlags: ReadonlyArray<Param.AnyFlag> = []
+): Completions.CommandDescriptor => {
   const impl = toImpl(cmd)
   const config = impl.config
 
   const flags: Array<Completions.FlagDescriptor> = []
-  for (const flag of config.flags) {
+  const seen = new Set<string>()
+  // Match help's precedence: local flags first, then ancestors root to leaf.
+  for (const [index, flag] of [...config.flags, ...inheritedFlags].entries()) {
     const singles = Param.extractSingleParams(flag)
     for (const single of singles) {
       if (single.kind !== "flag") continue
       // Omit hidden flags from completion scripts so tab-completion in the
       // shell does not advertise flags that are absent from --help.
       if (single.hidden) continue
+      if (index >= config.flags.length && seen.has(single.name)) continue
+      seen.add(single.name)
       flags.push({
         name: single.name,
         aliases: single.aliases,
@@ -108,12 +115,17 @@ export const fromCommand = (cmd: Command.Any): Completions.CommandDescriptor =>
   }
 
   const subcommands: Array<Completions.CommandDescriptor> = []
+  const sharedFlags = [...inheritedFlags, ...impl.contextConfig.flags]
   for (const group of cmd.subcommands) {
     for (const subcommand of group.commands) {
       // Omit unlisted subcommands from completion scripts so tab-completion in
       // the shell does not advertise commands that are absent from --help.
       if (subcommand.unlisted) continue
-      subcommands.push(fromCommand(subcommand))
+      const descriptor = fromCommand(subcommand, sharedFlags)
+      subcommands.push(descriptor)
+      if (subcommand.alias && subcommand.alias !== subcommand.name) {
+        subcommands.push({ ...descriptor, name: subcommand.alias })
+      }
     }
   }
 

package/src/unstable/cli/internal/completions/fish.ts

@@ -12,7 +12,10 @@ import type * as Completions from "../../Completions.ts"
 // Helpers
 // ---------------------------------------------------------------------------
 
-const escapeFishString = (s: string): string => s.replace(/'/g, "\\'")
+const escapeFishString = (s: string): string => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")
+
+/** Escape choices for Fish's second expansion of `complete -a`. */
+const escapeFishChoice = (s: string): string => escapeFishString(s.replace(/[^A-Za-z0-9_.,/@%+-]/gu, "\\$&"))
 
 /**
  * Build a Fish condition that checks the current subcommand context.
@@ -64,6 +67,15 @@ const flagContainsOptCondition = (flag: Completions.FlagDescriptor): string => {
   return `not __fish_contains_opt ${optArgs.join(" ")}`
 }
 
+/** Hide used value flags without suppressing their value completions. */
+const valueFlagDedupCondition = (flag: Completions.FlagDescriptor): string => {
+  const forms = [`--${flag.name}`]
+  for (const alias of flag.aliases) {
+    forms.push(alias.length === 1 ? `-${alias}` : `--${alias}`)
+  }
+  return `begin; ${flagContainsOptCondition(flag)}; or contains -- (commandline -poc)[-1] ${forms.join(" ")}; end`
+}
+
 const flagCompletionArgs = (flag: Completions.FlagDescriptor): Array<string> => {
   const args: Array<string> = [`-l ${flag.name}`]
   for (const alias of flag.aliases) {
@@ -88,7 +100,7 @@ const flagValueArgs = (type: Completions.FlagType): string | undefined => {
     case "Boolean":
       return undefined
     case "Choice":
-      return `-r -f -a '${type.values.join(" ")}'`
+      return `-r -f -a '${type.values.map(escapeFishChoice).join(" ")}'`
     case "Path":
       if (type.pathType === "directory") return `-r -F`
       return `-r -F`
@@ -101,7 +113,7 @@ const flagValueArgs = (type: Completions.FlagType): string | undefined => {
 const argValueArgs = (type: Completions.ArgumentType): string | undefined => {
   switch (type._tag) {
     case "Choice":
-      return `-r -f -a '${type.values.join(" ")}'`
+      return `-r -f -a '${type.values.map(escapeFishChoice).join(" ")}'`
     case "Path":
       return `-r -F`
     default:
@@ -147,13 +159,9 @@ const generateCompletions = (
 
   // Flag completions
   for (const flag of descriptor.flags) {
-    // Only apply __fish_contains_opt dedup for boolean flags. For value-taking
-    // flags, the dedup condition would suppress the entry while fish is waiting
-    // for a value (e.g. typing `--env <TAB>` wouldn't show choices).
     const isBoolean = flag.type._tag === "Boolean"
-    const flagCondition = isBoolean
-      ? (condition ? `${condition}; and ${flagContainsOptCondition(flag)}` : flagContainsOptCondition(flag))
-      : condition
+    const dedup = isBoolean ? flagContainsOptCondition(flag) : valueFlagDedupCondition(flag)
+    const flagCondition = condition ? `${condition}; and ${dedup}` : dedup
     const flagCondArg = flagCondition ? `-n '${flagCondition}'` : ``
 
     const parts = [`complete -c ${executableName}`]

package/src/unstable/cli/internal/completions/zsh.ts

@@ -14,6 +14,9 @@ import type * as Completions from "../../Completions.ts"
 
 const escapeZsh = (s: string): string => s.replace(/\\/g, "\\\\").replace(/'/g, "'\\''").replace(/:/g, "\\:")
 
+/** Escape choices for the second parse of a Zsh `_arguments` action. */
+const escapeZshChoice = (s: string): string => s.replace(/[^A-Za-z0-9_.,/@%+-]/gu, "\\$&").replace(/'/g, "'\\''")
+
 const sanitize = (s: string): string => s.replace(/[^a-zA-Z0-9_]/g, "_")
 
 /**
@@ -35,12 +38,12 @@ const valueAction = (type: Completions.FlagType): string => {
     case "Boolean":
       return ""
     case "Choice":
-      return `:value:(${type.values.join(" ")})`
+      return `:value:(${type.values.map(escapeZshChoice).join(" ")})`
     case "Path":
       return type.pathType === "directory" ? `:directory:_directories` : `:file:_files`
-    case "Integer":
+    case "Int":
       return `:integer:`
-    case "Float":
+    case "Finite":
       return `:float:`
     case "Date":
       return `:date:`
@@ -52,7 +55,7 @@ const valueAction = (type: Completions.FlagType): string => {
 const argAction = (type: Completions.ArgumentType): string => {
   switch (type._tag) {
     case "Choice":
-      return `(${type.values.join(" ")})`
+      return `(${type.values.map(escapeZshChoice).join(" ")})`
     case "Path":
       return type.pathType === "directory" ? `_directories` : `_files`
     default:

package/src/unstable/cli/internal/config.ts

@@ -15,12 +15,12 @@
  * ```ts
  * // User declares:
  * const config = {
- *   verbose: Flag.boolean("verbose").pipe(Flag.withDefault(false)),
+ *   verbose: Flag.Boolean("verbose").pipe(Flag.withDefault(false)),
  *   server: {
- *     host: Flag.string("host"),
- *     port: Flag.integer("port")
+ *     host: Flag.String("host"),
+ *     port: Flag.Int("port")
  *   },
- *   files: Argument.string("files").pipe(Argument.variadic)
+ *   files: Argument.String("files").pipe(Argument.variadic)
  * }
  *
  * // Becomes Config.Internal:

package/src/unstable/cli/internal/parser.ts

@@ -408,7 +408,7 @@ const missingFlagValue = (spec: FlagParam): CliError.InvalidValue => {
  * Recognizes: true/false, yes/no, on/off, 1/0
  */
 const asBooleanLiteral = (token: Token | undefined): string | undefined =>
-  token?._tag === "Value" && (Primitive.isTrueValue(token.value) || Primitive.isFalseValue(token.value))
+  token?._tag === "Value" && (Primitive.isTrueLiteral(token.value) || Primitive.isFalseLiteral(token.value))
     ? token.value
     : undefined
 

package/src/unstable/cli/internal/wizard.ts

@@ -16,17 +16,30 @@ export interface Options {
   readonly prefix?: ReadonlyArray<string> | undefined
 }
 
+export interface Result {
+  readonly args: Array<string>
+  readonly displayArgs: Array<string>
+}
+
+interface CommandLineArg {
+  readonly value: string
+  readonly displayValue: string
+}
+
 export const run: (
   command: Command.Command.Any,
   options?: Options
-) => Effect.Effect<Array<string>, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
+) => Effect.Effect<Result, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
   function*(command, options) {
     const commandPath = options?.commandPath ?? [command.name]
     const selected = getCommandAtPath(command, commandPath)
-    const commandLine = [...(options?.prefix ?? commandPath)]
+    const commandLine = (options?.prefix ?? commandPath).map((value) => commandLineArg(value))
     yield* logCurrentCommand(commandLine)
     yield* promptCommand(selected, commandLine, selected === command ? "ROOT" : selected.name)
-    return commandLine
+    return {
+      args: commandLine.map((arg) => arg.value),
+      displayArgs: commandLine.map((arg) => arg.displayValue)
+    }
   }
 )
 
@@ -49,7 +62,7 @@ const getCommandAtPath = (
 
 const promptCommand: (
   command: Command.Command.Any,
-  commandLine: Array<string>,
+  commandLine: Array<CommandLineArg>,
   sectionName: string
 ) => Effect.Effect<void, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
   function*(command, commandLine, sectionName) {
@@ -81,7 +94,7 @@ const promptCommand: (
       return
     }
 
-    const child = yield* Prompt.run(Prompt.select({
+    const child = yield* Prompt.run(Prompt.Select({
       message: "Command",
       choices: visibleSubcommands.map((command) => ({
         title: command.name,
@@ -94,7 +107,7 @@ const promptCommand: (
       }))
     }))
     yield* Console.log()
-    commandLine.push(child.name)
+    commandLine.push(commandLineArg(child.name))
     if (hasWizardSteps(child)) {
       yield* logCurrentCommand(commandLine)
     }
@@ -107,15 +120,17 @@ const hasWizardSteps = (command: Command.Command.Any): boolean => {
   return hasVisibleSubcommands || toImpl(command).config.orderedParams.length > 0
 }
 
-const promptParam: (
-  param: Param.Any
-) => Effect.Effect<Array<string>, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
-  function*(param) {
+const promptParam = Effect.fnUntraced(
+  function*(param: Param.Any): Effect.fn.Return<
+    Array<CommandLineArg>,
+    CliError.CliError | Terminal.QuitError,
+    Command.Environment
+  > {
     const single = Param.getUnderlyingSingleOrThrow(param)
     const metadata = Param.getParamMetadata(param)
 
     if (metadata.isOptional) {
-      const include = yield* Prompt.run(Prompt.confirm({
+      const include = yield* Prompt.run(Prompt.Confirm({
         message: `Set ${renderParamLabel(single)}?`,
         initial: false
       }))
@@ -127,25 +142,25 @@ const promptParam: (
 
     const count = !metadata.isVariadic
       ? 1
-      : yield* Prompt.run(Prompt.integer({
+      : yield* Prompt.run(Prompt.Int({
         message: `${renderParamLabel(single)} count`,
         default: Option.getOrElse(metadata.variadicMin, () => 0),
         min: Option.getOrElse(metadata.variadicMin, () => 0),
         ...(Option.isSome(metadata.variadicMax) ? { max: metadata.variadicMax.value } : {})
       }))
-    const values: Array<string> = []
+    const values: Array<CommandLineArg> = []
     for (let i = 0; i < count; i++) {
       values.push(yield* promptSingle(single))
     }
 
     const parsed = single.kind === Param.flagKind
       ? {
-        flags: { [single.name]: values },
+        flags: { [single.name]: values.map((arg) => arg.value) },
         arguments: []
       }
       : {
         flags: {},
-        arguments: values
+        arguments: values.map((arg) => arg.value)
       }
     yield* param.parse(parsed)
     yield* Console.log()
@@ -153,18 +168,23 @@ const promptParam: (
     if (single.kind === Param.argumentKind) {
       return values
     }
-    return values.flatMap((value) => [`--${single.name}`, value])
+    // Inline option-looking values so the lexer cannot interpret them as flags or the -- delimiter.
+    return values.flatMap((value) =>
+      value.value.startsWith("-") && value.value.length > 1
+        ? [commandLineArg(`--${single.name}=${value.value}`, `--${single.name}=${value.displayValue}`)]
+        : [commandLineArg(`--${single.name}`), value]
+    )
   }
 )
 
 const promptSingle = (
   single: Param.Single<Param.ParamKind, unknown>
-): Effect.Effect<string, Terminal.QuitError, Command.Environment> => {
+): Effect.Effect<CommandLineArg, Terminal.QuitError, Command.Environment> => {
   const message = renderParamMessage(single)
   switch (single.primitiveType._tag) {
     case "Boolean":
       return Effect.map(
-        Prompt.run(Prompt.confirm({
+        Prompt.run(Prompt.Confirm({
           message,
           label: {
             confirm: "true",
@@ -175,28 +195,36 @@ const promptSingle = (
             defaultDeny: "(t/F)"
           }
         })),
-        String
+        (value) => commandLineArg(String(value))
       )
     case "Choice": {
       const choices = Primitive.getChoiceKeys(single.primitiveType) ?? []
-      return Prompt.run(Prompt.select({
-        message,
-        choices: choices.map((choice) => ({ title: choice, value: choice }))
-      }))
+      return Effect.map(
+        Prompt.run(Prompt.Select({
+          message,
+          choices: choices.map((choice) => ({ title: choice, value: choice }))
+        })),
+        commandLineArg
+      )
     }
     case "Date":
-      return Effect.map(Prompt.run(Prompt.date({ message })), (date) => date.toISOString())
-    case "Float":
-      return Effect.map(Prompt.run(Prompt.float({ message })), String)
-    case "Integer":
-      return Effect.map(Prompt.run(Prompt.integer({ message })), String)
+      return Effect.map(Prompt.run(Prompt.Date({ message })), (date) => commandLineArg(date.toISOString()))
+    case "Finite":
+      return Effect.map(Prompt.run(Prompt.Number({ message })), (value) => commandLineArg(String(value)))
+    case "Int":
+      return Effect.map(Prompt.run(Prompt.Int({ message })), (value) => commandLineArg(String(value)))
     case "Redacted":
-      return Effect.map(Prompt.run(Prompt.password({ message })), Redacted.value)
+      return Effect.map(
+        Prompt.run(Prompt.Password({ message })),
+        (value) => commandLineArg(Redacted.value(value), "<redacted>")
+      )
     default:
-      return Prompt.run(Prompt.text({ message }))
+      return Effect.map(Prompt.run(Prompt.String({ message })), commandLineArg)
   }
 }
 
+const commandLineArg = (value: string, displayValue: string = value): CommandLineArg => ({ value, displayValue })
+
 const formatName = (single: Param.Single<Param.ParamKind, unknown>): string =>
   single.kind === Param.flagKind ? `--${single.name}` : single.name
 
@@ -216,8 +244,8 @@ const humanize = (name: string): string => {
   return [words[0][0].toUpperCase() + words[0].slice(1), ...words.slice(1)].join(" ")
 }
 
-const logCurrentCommand = (commandLine: ReadonlyArray<string>): Effect.Effect<void> =>
-  Console.log(renderCommandBlock("Current command", commandLine, Ansi.magenta))
+const logCurrentCommand = (commandLine: ReadonlyArray<CommandLineArg>): Effect.Effect<void> =>
+  Console.log(renderCommandBlock("Current command", commandLine.map((arg) => arg.displayValue), Ansi.magenta))
 
 const renderSection = (commandName: string, section: string): string =>
   `${Ansi.annotate(commandName.toUpperCase(), Ansi.bold, Ansi.cyanBright)} ${Ansi.annotate("·", Ansi.blackBright)} ${