effect 4.0.5 → 4.0.7

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

@@ -7,7 +7,7 @@
  * @internal
  */
 import type * as Completions from "../../Completions.ts"
-import { takesSeparateValue } from "./descriptor.ts"
+import { negatedName, takesSeparateValue } from "./descriptor.ts"
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -22,8 +22,9 @@ const flagNamesForWordlist = (flag: Completions.FlagDescriptor): Array<string> =
   for (const alias of flag.aliases) {
     names.push(alias.length === 1 ? `-${alias}` : `--${alias}`)
   }
-  if (flag.type._tag === "Boolean") {
-    names.push(`--no-${flag.name}`)
+  const negation = negatedName(flag)
+  if (negation !== undefined) {
+    names.push(`--${negation}`)
   }
   return names
 }
@@ -50,6 +51,10 @@ const buildFlagGroupDeclarations = (
   lines.push(``)
 }
 
+// Quoting these substitutions breaks quote matching on Bash 3.2.
+const removeQuotes = (variable: string): string =>
+  [`\\\\`, `\\"`, `\\'`].map((quote) => `${variable}=\${${variable}//${quote}/}`).join("; ")
+
 /**
  * Complete choices without `compgen -W`, which reparses quoted values. Escape
  * only the portion readline replaces for the active quote context.
@@ -70,9 +75,8 @@ const choicesHelper = (helperName: string, lines: Array<string>): void => {
   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(`  ${removeQuotes("_prefix")}`)
+  lines.push(`  ${removeQuotes("_committed")}`)
   lines.push(``)
   lines.push(`  COMPREPLY=()`)
   lines.push(`  local _choice _rest _match`)
@@ -110,30 +114,76 @@ const choicesHelper = (helperName: string, lines: Array<string>): void => {
   lines.push(``)
 }
 
-const choiceCompletion = (helperName: string, values: ReadonlyArray<string>): string =>
-  `${helperName} "$cur" "$_comp_word" ${values.map((value) => `'${escapeForBash(value)}'`).join(" ")}`
+interface Helpers {
+  readonly choices: string
+  readonly paths: string
+}
 
-const flagValueCompletion = (type: Completions.FlagType, helperName: string): string | undefined => {
-  switch (type._tag) {
-    case "Boolean":
-      return undefined
-    case "Choice":
-      return choiceCompletion(helperName, type.values)
-    case "Path":
-      if (type.pathType === "directory") return `COMPREPLY=( $(compgen -d -- "$cur") )`
-      return `COMPREPLY=( $(compgen -f -- "$cur") )`
-    default:
-      return undefined
-  }
+/**
+ * Complete paths through the choice helper, one `compgen` line per candidate.
+ * The typed directory is kept as written so expansions in it still apply; only
+ * the completed name is quoted.
+ */
+const pathsHelper = (helpers: Helpers, lines: Array<string>): void => {
+  lines.push(`${helpers.paths}()`)
+  lines.push(`{`)
+  lines.push(`  local _kind="$1" _cur="$2" _word="$3"`)
+  lines.push(``)
+  lines.push(`  local _prefix="$_cur" _committed="\${_cur%"$_word"}"`)
+  lines.push(`  ${removeQuotes("_prefix")}`)
+  lines.push(`  ${removeQuotes("_committed")}`)
+  lines.push(``)
+  // Track a quote the typed directory leaves open.
+  lines.push(`  local _typed="" _dir="$_committed" _open="" _i`)
+  lines.push(`  if [[ "$_word" == */* ]]; then`)
+  lines.push(`    _typed="\${_word%/*}/"`)
+  lines.push(`    _dir="\${_prefix%/*}/"`)
+  lines.push(`    if [[ "$_cur" == "$_word" ]]; then`)
+  lines.push(`      for ((_i = 0; _i < \${#_typed}; _i++)); do`)
+  lines.push(`        case "$_open\${_typed:_i:1}" in`)
+  lines.push(`          \\\\|\\"\\\\) ((_i += 1)) ;;`)
+  lines.push(`          \\"|\\') _open="\${_typed:_i:1}" ;;`)
+  lines.push(`          \\"\\"|\\'\\') _open="" ;;`)
+  lines.push(`        esac`)
+  lines.push(`      done`)
+  lines.push(`    fi`)
+  lines.push(`  fi`)
+  lines.push(``)
+  lines.push(`  local _path _names=() _rest="\${_word#"$_typed"}"`)
+  lines.push(`  while IFS= read -r _path; do`)
+  lines.push(`    if [[ "$_path" == "$_dir"* ]]; then`)
+  lines.push(`      _names+=("$_committed\${_path#"$_dir"}")`)
+  lines.push(`    elif [[ -z "$_committed" ]]; then`)
+  // Bash 3.2 returns expanded paths, which replace the whole word.
+  lines.push(`      _names+=("$_path")`)
+  lines.push(`      _typed="" _rest="" _open=""`)
+  lines.push(`    fi`)
+  lines.push(`  done < <(compgen "$_kind" -- "$_prefix")`)
+  // Close the quote before the name so a common prefix stays balanced.
+  lines.push(`  if [[ -n "$_open" ]]; then`)
+  lines.push(`    _typed+="$_open"`)
+  lines.push(`    _rest="\${_prefix##*/}"`)
+  lines.push(`  fi`)
+  lines.push(``)
+  lines.push(`  ${helpers.choices} "\${_cur%"$_word"}$_rest" "$_rest" "\${_names[@]}"`)
+  lines.push(`  for ((_i = 0; _i < \${#COMPREPLY[@]}; _i++)); do`)
+  lines.push(`    COMPREPLY[_i]="$_typed\${COMPREPLY[_i]}"`)
+  lines.push(`  done`)
+  lines.push(`}`)
+  lines.push(``)
 }
 
-const argCompletion = (type: Completions.ArgumentType, helperName: string): string | undefined => {
+const valueCompletion = (
+  type: Completions.FlagType | Completions.ArgumentType,
+  helpers: Helpers
+): string | undefined => {
   switch (type._tag) {
-    case "Choice":
-      return choiceCompletion(helperName, type.values)
+    case "Choice": {
+      const values = type.values.map((value) => `'${escapeForBash(value)}'`).join(" ")
+      return `${helpers.choices} "$cur" "$_comp_word" ${values}`
+    }
     case "Path":
-      if (type.pathType === "directory") return `COMPREPLY=( $(compgen -d -- "$cur") )`
-      return `COMPREPLY=( $(compgen -f -- "$cur") )`
+      return `${helpers.paths} ${type.pathType === "directory" ? "-d" : "-f"} "$cur" "$_comp_word"`
     default:
       return undefined
   }
@@ -147,7 +197,7 @@ const generateFunction = (
   descriptor: Completions.CommandDescriptor,
   parentPath: ReadonlyArray<string>,
   lines: Array<string>,
-  helperName: string
+  helpers: Helpers
 ): void => {
   const currentPath = [...parentPath, descriptor.name]
   const funcName = `_${currentPath.map(sanitizeFunctionName).join("_")}`
@@ -174,7 +224,7 @@ const generateFunction = (
       for (const alias of flag.aliases) {
         longNames.push(alias.length === 1 ? `-${alias}` : `--${alias}`)
       }
-      const completion = flagValueCompletion(flag.type, helperName)
+      const completion = valueCompletion(flag.type, helpers)
       if (completion) {
         lines.push(`    ${longNames.join("|")})`)
         lines.push(`      ${completion}`)
@@ -230,7 +280,7 @@ const generateFunction = (
 
   // Positional argument completion
   const argsWithCompletions = descriptor.arguments.flatMap((argument, index) => {
-    const completion = argCompletion(argument.type, helperName)
+    const completion = valueCompletion(argument.type, helpers)
     return completion === undefined ? [] : [{ argument, completion, index }]
   })
   if (argsWithCompletions.length > 0) {
@@ -286,7 +336,7 @@ const generateFunction = (
 
   // Recurse into subcommands
   for (const sub of descriptor.subcommands) {
-    generateFunction(sub, currentPath, lines, helperName)
+    generateFunction(sub, currentPath, lines, helpers)
   }
 }
 
@@ -300,7 +350,7 @@ export const generate = (
   const lines: Array<string> = []
   const safeName = sanitizeFunctionName(executableName)
   // Sanitized command names cannot contain `-`.
-  const helperName = `_${safeName}--choices`
+  const helpers: Helpers = { choices: `_${safeName}--choices`, paths: `_${safeName}--paths` }
 
   lines.push(`###-begin-${escapeForBash(executableName)}-completions-###`)
   lines.push(`#`)
@@ -340,8 +390,9 @@ export const generate = (
   lines.push(`fi`)
   lines.push(``)
 
-  choicesHelper(helperName, lines)
-  generateFunction(descriptor, [], lines, helperName)
+  choicesHelper(helpers.choices, lines)
+  pathsHelper(helpers, lines)
+  generateFunction(descriptor, [], lines, helpers)
 
   lines.push(`complete -F _${safeName} ${escapeForBash(executableName)}`)
   lines.push(`###-end-${escapeForBash(executableName)}-completions-###`)

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

@@ -96,7 +96,8 @@ export const fromCommand = (
         aliases: single.aliases,
         description: Option.getOrUndefined(single.description),
         type: toFlagType(single as Param.Single<"flag", unknown>),
-        optionalValue: single.optionalValue !== undefined
+        optionalValue: single.optionalValue !== undefined,
+        negation: single.negation
       })
     }
   }
@@ -148,3 +149,12 @@ export const fromCommand = (
  */
 export const takesSeparateValue = (flag: Completions.FlagDescriptor): boolean =>
   flag.type._tag !== "Boolean" && flag.optionalValue !== true
+
+/**
+ * Long name that sets a boolean flag to `false`, or `undefined` when the flag
+ * has no negated form.
+ *
+ * @internal
+ */
+export const negatedName = (flag: Completions.FlagDescriptor): string | undefined =>
+  flag.type._tag !== "Boolean" || flag.negation === false ? undefined : flag.negation ?? `no-${flag.name}`

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

@@ -7,7 +7,7 @@
  * @internal
  */
 import type * as Completions from "../../Completions.ts"
-import { takesSeparateValue } from "./descriptor.ts"
+import { negatedName, takesSeparateValue } from "./descriptor.ts"
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -62,8 +62,9 @@ const flagContainsOptCondition = (flag: Completions.FlagDescriptor): string => {
       optArgs.push(alias)
     }
   }
-  if (flag.type._tag === "Boolean") {
-    optArgs.push(`no-${flag.name}`)
+  const negation = negatedName(flag)
+  if (negation !== undefined) {
+    optArgs.push(negation)
   }
   return `not __fish_contains_opt ${optArgs.join(" ")}`
 }
@@ -170,10 +171,11 @@ const generateCompletions = (
     lines.push(parts.join(" "))
 
     // Boolean negation
-    if (flag.type._tag === "Boolean") {
+    const negation = negatedName(flag)
+    if (negation !== undefined) {
       const negParts = [`complete -c ${executableName}`]
       if (flagCondArg) negParts.push(flagCondArg)
-      negParts.push(`-l no-${flag.name}`)
+      negParts.push(`-l ${negation}`)
       if (flag.description) {
         negParts.push(`-d '${escapeFishString(`Disable ${flag.name}`)}'`)
       }
@@ -192,7 +194,7 @@ const generateCompletions = (
 
     for (const flag of descriptor.flags) {
       const bareCondition = `${bareBase}; and ${flagContainsOptCondition(flag)}`
-      const isBoolean = flag.type._tag === "Boolean"
+      const negation = negatedName(flag)
 
       const parts = [`complete -c ${executableName}`]
       parts.push(`-n '${bareCondition}'`)
@@ -202,10 +204,10 @@ const generateCompletions = (
       }
       lines.push(parts.join(" "))
 
-      if (isBoolean) {
+      if (negation !== undefined) {
         const negParts = [`complete -c ${executableName}`]
         negParts.push(`-n '${bareCondition}'`)
-        negParts.push(`-f -a '--no-${flag.name}'`)
+        negParts.push(`-f -a '--${negation}'`)
         if (flag.description) {
           negParts.push(`-d '${escapeFishString(`Disable ${flag.name}`)}'`)
         }

package/src/cli/internal/completions/powershell.ts

@@ -8,6 +8,7 @@
  * @internal
  */
 import type * as Completions from "../../Completions.ts"
+import { negatedName } from "./descriptor.ts"
 
 /**
  * Encode non-ASCII and control characters as `[char]` code units. Windows
@@ -46,12 +47,15 @@ const valueFields = (type: Completions.FlagType | Completions.ArgumentType): str
   `values = ${psArray(type._tag === "Choice" ? type.values : [])}; ` +
   `pathType = ${type._tag === "Path" ? quotePs(type.pathType) : "$null"}`
 
-const flagEntry = (flag: Completions.FlagDescriptor): string =>
-  `@{ name = ${quotePs(flag.name)}; forms = ${psArray(flagForms(flag))}; ` +
-  `takesValue = $${flag.type._tag !== "Boolean"}; ` +
-  (flag.optionalValue === true ? `optionalValue = $true; ` : "") +
-  `${valueFields(flag.type)}; ` +
-  `description = ${psOptional(flag.description)} }`
+const flagEntry = (flag: Completions.FlagDescriptor): string => {
+  const negation = negatedName(flag)
+  return `@{ name = ${quotePs(flag.name)}; forms = ${psArray(flagForms(flag))}; ` +
+    `takesValue = $${flag.type._tag !== "Boolean"}; ` +
+    (negation === undefined ? "" : `negation = ${quotePs(`--${negation}`)}; `) +
+    (flag.optionalValue === true ? `optionalValue = $true; ` : "") +
+    `${valueFields(flag.type)}; ` +
+    `description = ${psOptional(flag.description)} }`
+}
 
 const argumentEntry = (argument: Completions.ArgumentDescriptor): string =>
   `@{ name = ${quotePs(argument.name)}; variadic = $${argument.variadic}; ${valueFields(argument.type)}; ` +
@@ -154,10 +158,10 @@ const completer = (dataName: string): string =>
       foreach ($form in $flag.forms) {
         & $add $form 'ParameterName' $flag.description $typed ''
       }
-      if (-not $flag.takesValue) {
+      if ($flag.negation) {
         $tooltip = $null
         if ($flag.description) { $tooltip = 'Disable ' + $flag.name }
-        & $add ('--no-' + $flag.name) 'ParameterName' $tooltip $typed ''
+        & $add $flag.negation 'ParameterName' $tooltip $typed ''
       }
     }
   }
@@ -228,14 +232,19 @@ const completer = (dataName: string): string =>
       foreach ($form in $forms) {
         $pending = $null
         $flag = $lookup[$form]
-        if ($null -eq $flag) {
-          if ($form.StartsWith('--no-')) {
-            $name = $form.Substring(5)
-            $flag = $lookup['--' + $name]
-            if ($null -ne $flag -and -not $flag.takesValue -and $flag.name -ceq $name) { $used[$name] = $true }
+        # As in the CLI parser, a negation wins over an alias but not over a
+        # canonical name.
+        if ($null -eq $flag -or $form -cne ('--' + $flag.name)) {
+          $negated = $null
+          foreach ($candidate in $context.flags) {
+            if ($candidate.negation -ceq $form) { $negated = $candidate }
+          }
+          if ($null -ne $negated) {
+            $used[$negated.name] = $true
+            continue
           }
-          continue
         }
+        if ($null -eq $flag) { continue }
         $used[$flag.name] = $true
         # A flag with an optional value only takes a value attached with '='.
         if (-not $hasValue -and -not $flag.optionalValue) { $pending = $flag }

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

@@ -7,6 +7,7 @@
  * @internal
  */
 import type * as Completions from "../../Completions.ts"
+import { negatedName } from "./descriptor.ts"
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -22,15 +23,16 @@ const escapeZshChoice = (s: string): string => s.replace(/[^A-Za-z0-9_.,/@%+-]/g
 const sanitize = (s: string): string => s.replace(/[^a-zA-Z0-9_]/g, "_")
 
 /**
- * All forms of a flag (--name, -alias, --no-name) for the exclusion group.
+ * All forms of a flag (--name, -alias, negation) for the exclusion group.
  */
 const allForms = (flag: Completions.FlagDescriptor): Array<string> => {
   const forms: Array<string> = [`--${flag.name}`]
   for (const alias of flag.aliases) {
     forms.push(alias.length === 1 ? `-${alias}` : `--${alias}`)
   }
-  if (flag.type._tag === "Boolean") {
-    forms.push(`--no-${flag.name}`)
+  const negation = negatedName(flag)
+  if (negation !== undefined) {
+    forms.push(`--${negation}`)
   }
   return forms
 }
@@ -89,9 +91,10 @@ const flagSpecs = (flag: Completions.FlagDescriptor): Array<string> => {
   }
 
   // Boolean negation
-  if (flag.type._tag === "Boolean") {
+  const negation = negatedName(flag)
+  if (negation !== undefined) {
     const negDesc = flag.description ? `[${escapeZshExplanation(`Disable ${flag.name}`)}]` : ""
-    specs.push(`'${excl}--no-${flag.name}${negDesc}'`)
+    specs.push(`'${excl}--${negation}${negDesc}'`)
   }
 
   return specs

package/src/cli/internal/formatter.ts

@@ -0,0 +1,18 @@
+import * as Context from "../../Context.ts"
+import * as Effect from "../../Effect.ts"
+import * as CliOutput from "../CliOutput.ts"
+import * as TerminalCapabilities from "../TerminalCapabilities.ts"
+
+/**
+ * The formatter for built-in command output. An installed `CliOutput.Formatter`
+ * wins, otherwise the default formatter colors when `TerminalCapabilities`
+ * says it can.
+ *
+ * @internal
+ */
+export const resolveFormatter: Effect.Effect<CliOutput.Formatter> = Effect.contextWith((context) =>
+  Effect.succeed(
+    Context.getOrUndefined(context, CliOutput.Formatter) ??
+      CliOutput.defaultFormatter({ colors: Context.get(context, TerminalCapabilities.TerminalCapabilities).canColor })
+  )
+)

package/src/cli/internal/lexer.ts

@@ -58,8 +58,12 @@ const lexTokens = (args: ReadonlyArray<string>): ReadonlyArray<Token> => {
       const equalIndex = arg.indexOf("=")
       if (equalIndex !== -1) {
         const name = arg.slice(2, equalIndex)
-        const value = arg.slice(equalIndex + 1)
-        tokens.push({ _tag: "LongOption", name, raw: arg, value })
+        if (name === "") {
+          tokens.push({ _tag: "Value", value: arg })
+        } else {
+          const value = arg.slice(equalIndex + 1)
+          tokens.push({ _tag: "LongOption", name, raw: arg, value })
+        }
       } else {
         tokens.push({ _tag: "LongOption", name: arg.slice(2), raw: arg })
       }
@@ -67,9 +71,12 @@ const lexTokens = (args: ReadonlyArray<string>): ReadonlyArray<Token> => {
       const flags = arg.slice(1)
       const equalIndex = flags.indexOf("=")
       if (equalIndex !== -1) {
-        const flag = flags.slice(0, equalIndex)
-        const value = flags.slice(equalIndex + 1)
-        tokens.push({ _tag: "ShortOption", flag, raw: `-${flag}`, value })
+        const chars = Array.from(flags.slice(0, equalIndex))
+        const flag = chars.pop() ?? ""
+        for (const ch of chars) {
+          tokens.push({ _tag: "ShortOption", flag: ch, raw: `-${ch}` })
+        }
+        tokens.push({ _tag: "ShortOption", flag, raw: `-${flag}`, value: flags.slice(equalIndex + 1) })
       } else {
         for (const ch of flags) {
           tokens.push({ _tag: "ShortOption", flag: ch, raw: `-${ch}` })

package/src/cli/internal/parser.ts

@@ -125,6 +125,8 @@ type FlagRegistry = {
   readonly params: ReadonlyArray<FlagParam>
   /** Maps canonical names and aliases → flag param */
   readonly index: Map<string, FlagParam>
+  /** Maps negated names of boolean flags → flag param */
+  readonly negations: Map<string, FlagParam>
 }
 
 /**
@@ -229,12 +231,22 @@ const makeCursor = (tokens: ReadonlyArray<Token>): TokenCursor => {
 /* Flag Registry                                                              */
 /* ========================================================================== */
 
+/**
+ * Long name that sets a boolean flag to `false`, or `undefined` when the flag
+ * has no negated form.
+ */
+const negatedName = (param: FlagParam): string | undefined =>
+  !Primitive.isBoolean(param.primitiveType) || param.negation === false
+    ? undefined
+    : param.negation ?? `no-${param.name}`
+
 /**
  * Creates a registry for O(1) flag lookup by name or alias.
  * @internal
  */
 export const createFlagRegistry = (params: ReadonlyArray<FlagParam>): FlagRegistry => {
   const index = new Map<string, FlagParam>()
+  const negations = new Map<string, FlagParam>()
 
   for (const param of params) {
     if (index.has(param.name)) {
@@ -250,9 +262,19 @@ export const createFlagRegistry = (params: ReadonlyArray<FlagParam>): FlagRegist
       }
       index.set(alias, param)
     }
+
+    const negation = negatedName(param)
+    if (negation !== undefined) {
+      if (negations.has(negation)) {
+        throw new Error(
+          `Duplicate negation "${negation}" in command definition (conflicts with "${negations.get(negation)!.name}")`
+        )
+      }
+      negations.set(negation, param)
+    }
   }
 
-  return { params, index }
+  return { params, index, negations }
 }
 
 const buildSubcommandIndex = (
@@ -362,14 +384,11 @@ const resolveFlag = (
     }
   }
 
-  if (token._tag === "LongOption" && token.name.startsWith("no-")) {
-    const canonicalName = token.name.slice(3)
-    const param = registry.index.get(canonicalName)
-    if (param && param.name === canonicalName && Primitive.isBoolean(param.primitiveType)) {
-      return {
-        param,
-        negated: true
-      }
+  const negated = token._tag === "LongOption" ? registry.negations.get(token.name) : undefined
+  if (negated) {
+    return {
+      param: negated,
+      negated: true
     }
   }
 
@@ -740,8 +759,9 @@ const createUnrecognizedFlagError = (
     // that was intentionally kept out of --help.
     if (p.hidden) continue
     validNames.push(p.name)
-    if (Primitive.isBoolean(p.primitiveType)) {
-      validNames.push(`no-${p.name}`)
+    const negation = negatedName(p)
+    if (negation !== undefined) {
+      validNames.push(negation)
     }
     for (const alias of p.aliases) {
       validNames.push(alias)