refactor: Make -y the short flag for --non-interactive

-y differed from --non-interactive only by prompting instead of failing
when something was missing, which is not worth a separate flag. Collapse
them: -y is now simply the short flag for --non-interactive, and its
--yes long form is dropped.

This leaves -n unused so it can become --dry-run.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TxQCkfVypobQVA7DpF4jvx

Author: claude

README.md

@@ -11,7 +11,7 @@ A command line interface (CLI) for interacting with the Seam API.
 
 Every command is interactive: the CLI prompts for any missing required
 parameter with suggestions pulled from your workspace. Pass `--non-interactive`
-(or `-n`) to never be prompted: the command fails instead.
+(or `-y`) to never be prompted: the command fails instead.
 
 ## Installation
 
@@ -35,15 +35,11 @@ $ paru -S seam-bin
 Every `seam` command is interactive and will prompt you for any missing
 required properties with helpful suggestions.
 
-For scripts and CI, pass `--non-interactive` (or `-n`) to never be prompted.
+For scripts and CI, pass `--non-interactive` (or `-y`) to never be prompted.
 The command must then be complete: if the command itself is ambiguous, or any
 required property is missing, the CLI exits with an error naming what is
 missing instead of asking for it.
 
-Pass `--yes` (or `-y`) to only skip the prompt to review properties before the
-API call is made. Unlike `--non-interactive`, anything still missing is
-prompted for.
-
 ```bash
 # Login to Seam
 seam login

src/bin/cli.ts

@@ -19,10 +19,9 @@ import { interactForUseRemoteApiDefs } from 'lib/interact-for-use-remote-api-def
 import { interactForWorkspaceId } from 'lib/interact-for-workspace-id.js'
 import type { ContextHelpers } from 'lib/types.js'
 import {
-  getInteractivity,
-  type Interactivity,
-  interactivityFlags,
+  isInteractive,
   NonInteractiveError,
+  nonInteractiveFlags,
   parseCliArgs,
 } from 'lib/util/cli-args.js'
 import { RequestSeamApi } from 'lib/util/request-seam-api.js'
@@ -33,7 +32,7 @@ const sections = [
   {
     header: 'Seam CLI',
     content:
-      'Every seam command is interactive and will prompt you for any missing required properties with helpful suggestions. To never be prompted, pass -n ',
+      'Every seam command is interactive and will prompt you for any missing required properties with helpful suggestions. To never be prompted, pass -y ',
   },
   {
     header: 'Options',
@@ -48,13 +47,6 @@ const sections = [
         name: 'non-interactive',
         description:
           'Never prompt: exit with an error if the command or any required property is missing.',
-        alias: 'n',
-        type: Boolean,
-      },
-      {
-        name: 'yes',
-        description:
-          'Do not prompt to review properties when every required property was already given.',
         alias: 'y',
         type: Boolean,
       },
@@ -144,7 +136,7 @@ async function cli(args: ParsedArgs) {
 
   const ctx: ContextHelpers = {
     blueprint,
-    interactivity: getInteractivity(args),
+    is_interactive: isInteractive(args),
   }
 
   for (const k in args) {
@@ -153,7 +145,7 @@ async function cli(args: ParsedArgs) {
     delete args[k]
     const key = k.replace(/-/g, '_')
     args[key] = v
-    if (interactivityFlags.includes(key)) continue
+    if (nonInteractiveFlags.includes(key)) continue
     commandParams[key] = v
   }
 
@@ -256,28 +248,22 @@ async function cli(args: ParsedArgs) {
   if (response.data?.connect_webview) {
     await handleConnectWebviewResponse(
       response.data.connect_webview,
-      ctx.interactivity,
+      ctx.is_interactive,
     )
   }
 
-  if (
-    response.data?.action_attempt &&
-    ctx.interactivity !== 'non-interactive'
-  ) {
+  if (response.data?.action_attempt && ctx.is_interactive) {
     interactForActionAttemptPoll(response.data.action_attempt)
   }
 }
 
 const handleConnectWebviewResponse = async (
   connect_webview: any,
-  interactivity: Interactivity,
+  is_interactive: boolean,
 ) => {
   const url = connect_webview.url
 
-  if (
-    interactivity !== 'non-interactive' &&
-    process.env['INSIDE_WEB_BROWSER'] !== '1'
-  ) {
+  if (is_interactive && process.env['INSIDE_WEB_BROWSER'] !== '1') {
     const { action } = await prompts({
       type: 'confirm',
       name: 'action',

src/lib/interact-for-blueprint-object.test.ts

@@ -9,8 +9,10 @@ const parameters = [
   { name: 'name', isRequired: false, format: 'string' },
 ] as unknown as Parameter[]
 
-const ctx = (interactivity: ContextHelpers['interactivity']): ContextHelpers =>
-  ({ interactivity, blueprint: {} }) as unknown as ContextHelpers
+const nonInteractiveCtx = {
+  is_interactive: false,
+  blueprint: {},
+} as unknown as ContextHelpers
 
 const args = (params: Record<string, any>) => ({
   command: ['devices', 'get'],
@@ -22,26 +24,14 @@ test('interactForBlueprintObject: submits given parameters when non-interactive'
   await expect(
     interactForBlueprintObject(
       args({ device_id: 'device1' }),
-      ctx('non-interactive'),
-    ),
-  ).resolves.toEqual({ device_id: 'device1' })
-})
-
-test('interactForBlueprintObject: submits given parameters with -y', async () => {
-  await expect(
-    interactForBlueprintObject(
-      args({ device_id: 'device1' }),
-      ctx('auto-submit'),
+      nonInteractiveCtx,
     ),
   ).resolves.toEqual({ device_id: 'device1' })
 })
 
 test('interactForBlueprintObject: rejects missing required parameters when non-interactive', async () => {
   await expect(
-    interactForBlueprintObject(
-      args({ name: 'Front Door' }),
-      ctx('non-interactive'),
-    ),
+    interactForBlueprintObject(args({ name: 'Front Door' }), nonInteractiveCtx),
   ).rejects.toThrowError(
     'Missing required parameter for /devices/get: --device-id',
   )

src/lib/interact-for-blueprint-object.ts

@@ -50,15 +50,12 @@ export const interactForBlueprintObject = async (
 
   const cmdPath = `/${args.command.join('/').replace(/-/g, '_')}`
 
-  const should_auto_submit =
-    ctx.interactivity !== 'interactive' &&
-    haveAllRequiredParams &&
-    !args.isSubProperty
-  if (should_auto_submit) {
-    return args.params
-  }
+  if (!ctx.is_interactive) {
+    const should_auto_submit = haveAllRequiredParams && !args.isSubProperty
+    if (should_auto_submit) {
+      return args.params
+    }
 
-  if (ctx.interactivity === 'non-interactive') {
     const missing = required.filter((k) => !args.params[k])
     const target = args.isSubProperty ? `"${args.subPropertyPath}"` : cmdPath
     throw new NonInteractiveError(

src/lib/interact-for-command-selection.test.ts

@@ -4,7 +4,7 @@ import { interactForCommandSelection } from './interact-for-command-selection.js
 import type { ContextHelpers } from './types.js'
 
 const ctx = {
-  interactivity: 'non-interactive',
+  is_interactive: false,
   blueprint: {
     routes: [
       {

src/lib/interact-for-command-selection.ts

@@ -65,7 +65,7 @@ export async function interactForCommandSelection(
     return commandPath
   }
 
-  if (helpers.interactivity === 'non-interactive') {
+  if (!helpers.is_interactive) {
     // The command path is itself a command, so call it directly rather than
     // prompting to select one of its sub-commands.
     if (possibleCommands.some((cmd) => cmd.length === commandPath.length)) {

src/lib/types.ts

@@ -1,7 +1,6 @@
 import type { ApiBlueprint } from './get-api-blueprint.js'
-import type { Interactivity } from './util/cli-args.js'
 
 export interface ContextHelpers {
   blueprint: ApiBlueprint
-  interactivity: Interactivity
+  is_interactive: boolean
 }

src/lib/util/cli-args.test.ts

@@ -1,7 +1,7 @@
 import type { ParsedArgs } from 'minimist'
 import { expect, test } from 'vitest'
 
-import { getInteractivity, parseCliArgs, toArgName } from './cli-args.js'
+import { isInteractive, parseCliArgs, toArgName } from './cli-args.js'
 
 // The CLI normalizes argument keys before checking them.
 const parse = (argv: string[]): ParsedArgs => {
@@ -13,34 +13,23 @@ const parse = (argv: string[]): ParsedArgs => {
   return args
 }
 
-test('getInteractivity: interactive by default', () => {
-  expect(getInteractivity(parse(['devices', 'list']))).toBe('interactive')
+test('isInteractive: interactive by default', () => {
+  expect(isInteractive(parse(['devices', 'list']))).toBe(true)
 })
 
-test('getInteractivity: --non-interactive and -n never prompt', () => {
-  expect(
-    getInteractivity(parse(['devices', 'list', '--non-interactive'])),
-  ).toBe('non-interactive')
-  expect(getInteractivity(parse(['devices', 'list', '-n']))).toBe(
-    'non-interactive',
+test('isInteractive: --non-interactive and -y never prompt', () => {
+  expect(isInteractive(parse(['devices', 'list', '--non-interactive']))).toBe(
+    false,
   )
+  expect(isInteractive(parse(['devices', 'list', '-y']))).toBe(false)
 })
 
-test('getInteractivity: --yes and -y only skip the parameter prompt', () => {
-  expect(getInteractivity(parse(['devices', 'list', '--yes']))).toBe(
-    'auto-submit',
-  )
-  expect(getInteractivity(parse(['devices', 'list', '-y']))).toBe('auto-submit')
-})
-
-test('getInteractivity: --non-interactive wins over -y', () => {
-  expect(getInteractivity(parse(['devices', 'list', '-y', '-n']))).toBe(
-    'non-interactive',
-  )
+test('isInteractive: -n is reserved and does not affect interactivity', () => {
+  expect(isInteractive(parse(['devices', 'list', '-n']))).toBe(true)
 })
 
 test('parseCliArgs: --non-interactive does not consume the next argument', () => {
-  const args = parse(['devices', 'get', '-n', '--device-id', 'foo'])
+  const args = parse(['devices', 'get', '-y', '--device-id', 'foo'])
   expect(args['device_id']).toBe('foo')
   expect(args._).toEqual(['devices', 'get'])
 })

src/lib/util/cli-args.ts

@@ -1,22 +1,10 @@
 import parseArgs, { type ParsedArgs } from 'minimist'
 
 /**
- * How the CLI should behave when it needs input that was not given as an
- * argument.
- *
- * - `interactive`: prompt for it. This is the default.
- * - `auto-submit`: skip the parameter prompt when everything required
- *   was already given, otherwise prompt. Selected with `--yes` or `-y`.
- * - `non-interactive`: never prompt: missing input is an error.
- *   Selected with `--non-interactive` or `-n`.
- */
-export type Interactivity = 'interactive' | 'auto-submit' | 'non-interactive'
-
-/**
- * Argument keys that affect interactivity
+ * Argument keys that disable interactive prompts
  * and are therefore not command parameters.
  */
-export const interactivityFlags = ['non_interactive', 'n', 'yes', 'y']
+export const nonInteractiveFlags = ['non_interactive', 'y']
 
 /**
  * Thrown when the CLI needs input it cannot prompt for.
@@ -28,17 +16,20 @@ export class NonInteractiveError extends Error {
 export const parseCliArgs = (argv: string[]): ParsedArgs =>
   parseArgs(argv, {
     string: ['code'],
-    boolean: ['non-interactive', 'yes'],
-    alias: { 'non-interactive': 'n', yes: 'y' },
+    boolean: ['non-interactive'],
+    // Deliberately not aliased to -n, which is reserved for a future
+    // --dry-run flag.
+    alias: { 'non-interactive': 'y' },
   })
 
-export const getInteractivity = (args: ParsedArgs): Interactivity => {
-  if (args['non_interactive'] === true || args['n'] === true) {
-    return 'non-interactive'
-  }
-  if (args['yes'] === true || args['y'] === true) return 'auto-submit'
-  return 'interactive'
-}
+/**
+ * Whether or not the CLI may prompt for input.
+ *
+ * When false, the command must be given in full:
+ * anything missing is an error instead of a prompt.
+ */
+export const isInteractive = (args: ParsedArgs): boolean =>
+  !nonInteractiveFlags.some((flag) => args[flag] === true)
 
 /**
  * Render a parameter name as the argument used to set it,