feat(completion): complete context names for positional args

src/completion/enumerate.ts

@@ -32,14 +32,17 @@ export interface CompletionResult {
 export type DynamicCompleter = () => string[] | Promise<string[]>
 
 /**
- * Lookup table for dynamic completers keyed by flag long name (including `--`).
+ * Lookup table for dynamic completers keyed by flag long name (including `--`)
+ * or by command path (e.g. `"config current-context set"`).
  *
- * Returning `undefined` for an unknown flag is mandatory: the completion path
+ * Returning `undefined` for an unknown key is mandatory: the completion path
  * MUST NOT throw or block, so completers that are unavailable for the current
  * environment simply do not register themselves.
  */
 export interface DynamicCompleterRegistry {
   get(flagLong: string): DynamicCompleter | undefined
+  /** Returns a positional-argument completer for the given space-joined command path, if any. */
+  getPositional?(commandPath: string): DynamicCompleter | undefined
 }
 
 // Commander stores hidden state on an internal `_hidden` field that is not
@@ -110,6 +113,21 @@ function optionTakesArg (current: Command, root: Command, word: string): boolean
   return false
 }
 
+/**
+ * Builds a space-joined path for `cmd` excluding the root program name.
+ * e.g. the `set` subcommand under `elastic config current-context` → `"config current-context set"`.
+ */
+function getCommandPath (cmd: Command): string {
+  const parts: string[] = []
+  let c: Command | null = cmd
+  while (c != null && c.parent != null) {
+    parts.push(c.name())
+    c = c.parent
+  }
+  parts.reverse()
+  return parts.join(' ')
+}
+
 function prefixFilter (candidates: readonly string[], prefix: string): string[] {
   if (prefix === '') return [...candidates]
   return candidates.filter((c) => c.startsWith(prefix))
@@ -146,8 +164,9 @@ async function safeRun (fn: DynamicCompleter): Promise<string[]> {
  * 4. If the immediately previous token is a registered dynamic flag (e.g.
  *    `--use-context`), return that completer's candidates filtered by the
  *    current word.
- * 5. Otherwise, return the subcommand names and aliases of the deepest matched
- *    command/group, filtered by the current word.
+ * 5. Otherwise, if the deepest command is a leaf (no subcommands) and a
+ *    positional completer is registered for its path, return those candidates.
+ *    Falls back to subcommand names and aliases (empty for leaf commands).
  *
  * Result is always returned (never thrown). `directive` always carries
  * `DIRECTIVE_NO_FILE_COMP` so the shell does not fall back to filename
@@ -219,9 +238,22 @@ export async function enumerate (
     return { candidates: [], directive: DIRECTIVE_NO_FILE_COMP }
   }
 
-  const cands = collectChildren(current)
+  const children = collectChildren(current)
+  // Leaf command (no subcommands): offer a registered positional completer.
+  // Note: this fires regardless of how many positional args are already typed,
+  // so a single-positional command re-offers candidates after the first.
+  if (children.length === 0 && registry != null) {
+    const positionalCompleter = registry.getPositional?.(getCommandPath(current))
+    if (positionalCompleter != null) {
+      const cands = await safeRun(positionalCompleter)
+      return {
+        candidates: prefixFilter(cands, incomplete),
+        directive: DIRECTIVE_NO_FILE_COMP,
+      }
+    }
+  }
   return {
-    candidates: prefixFilter(cands, incomplete),
+    candidates: prefixFilter(children, incomplete),
     directive: DIRECTIVE_NO_FILE_COMP,
   }
 }

src/completion/registry.ts

@@ -21,9 +21,18 @@ const DEFAULT_COMPLETERS: ReadonlyMap<string, DynamicCompleter> = new Map([
   ['--use-context', completeContextNames],
 ])
 
+const POSITIONAL_COMPLETERS: ReadonlyMap<string, DynamicCompleter> = new Map([
+  ['config current-context set', completeContextNames],
+  ['config context edit', completeContextNames],
+  ['config context remove', completeContextNames],
+])
+
 /** The shared registry used by the `__complete` command. */
 export const defaultRegistry: DynamicCompleterRegistry = {
   get (flagLong: string): DynamicCompleter | undefined {
     return DEFAULT_COMPLETERS.get(flagLong)
   },
+  getPositional (commandPath: string): DynamicCompleter | undefined {
+    return POSITIONAL_COMPLETERS.get(commandPath)
+  },
 }

test/completion/enumerate.test.ts

@@ -245,6 +245,61 @@ describe('enumerate -- value-taking flag walk', () => {
   })
 })
 
+describe('enumerate -- positional completer registry', () => {
+  function buildProgramWithLeaf (): Command {
+    const program = buildSampleProgram()
+    const setCmd = defineCommand({
+      name: 'set',
+      description: 'Set current context',
+      positionalArg: { name: 'name', description: 'context name', required: true },
+      handler: () => ({}),
+    })
+    const currentCtx = defineGroup({ name: 'current-context', description: 'View or change current context' }, setCmd)
+    const config = defineGroup({ name: 'config', description: 'Config' }, currentCtx)
+    program.addCommand(config)
+    return program
+  }
+
+  it('invokes a positional completer for a leaf command', async () => {
+    const registry: DynamicCompleterRegistry = {
+      get: () => undefined,
+      getPositional: (path) => path === 'config current-context set' ? () => ['local', 'staging', 'prod'] : undefined,
+    }
+    const result = await enumerate(buildProgramWithLeaf(), ['config', 'current-context', 'set', ''], registry)
+    assert.deepEqual(result.candidates, ['local', 'staging', 'prod'])
+  })
+
+  it('prefix-filters positional candidates against the incomplete word', async () => {
+    const registry: DynamicCompleterRegistry = {
+      get: () => undefined,
+      getPositional: () => () => ['local', 'staging', 'prod'],
+    }
+    const result = await enumerate(buildProgramWithLeaf(), ['config', 'current-context', 'set', 'st'], registry)
+    assert.deepEqual(result.candidates, ['staging'])
+  })
+
+  it('returns empty (not throw) when positional completer rejects', async () => {
+    const registry: DynamicCompleterRegistry = {
+      get: () => undefined,
+      getPositional: () => () => { throw new Error('boom') },
+    }
+    const result = await enumerate(buildProgramWithLeaf(), ['config', 'current-context', 'set', ''], registry)
+    assert.deepEqual(result.candidates, [])
+  })
+
+  it('does not call getPositional when the command has children', async () => {
+    const calls: string[] = []
+    const registry: DynamicCompleterRegistry = {
+      get: () => undefined,
+      getPositional: (path) => { calls.push(path); return undefined },
+    }
+    // 'config' has children — should return children, not invoke positional
+    const result = await enumerate(buildProgramWithLeaf(), ['config', ''], registry)
+    assert.ok(result.candidates.includes('current-context'))
+    assert.deepEqual(calls, [])
+  })
+})
+
 describe('enumerate -- edge cases', () => {
   it('treats an unmatched prefix word as the current incomplete word', async () => {
     const result = await enumerate(buildSampleProgram(), ['zzz'])

test/completion/registry.test.ts

@@ -26,3 +26,23 @@ describe('defaultRegistry', () => {
     for (const name of result) assert.equal(typeof name, 'string')
   })
 })
+
+describe('defaultRegistry -- positional completers', () => {
+  it('registers a completer for config current-context set', () => {
+    assert.equal(typeof defaultRegistry.getPositional?.('config current-context set'), 'function')
+  })
+
+  it('registers a completer for config context edit', () => {
+    assert.equal(typeof defaultRegistry.getPositional?.('config context edit'), 'function')
+  })
+
+  it('registers a completer for config context remove', () => {
+    assert.equal(typeof defaultRegistry.getPositional?.('config context remove'), 'function')
+  })
+
+  it('returns undefined for unregistered command paths', () => {
+    assert.equal(defaultRegistry.getPositional?.('config context add'), undefined)
+    assert.equal(defaultRegistry.getPositional?.('config context list'), undefined)
+    assert.equal(defaultRegistry.getPositional?.(''), undefined)
+  })
+})