incur 0.4.0 → 0.4.2

package/src/Completions.test.ts

@@ -1,4 +1,8 @@
 import { Cli, Completions, z } from 'incur'
+import { execFile, spawnSync } from 'node:child_process'
+import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 const originalIsTTY = process.stdout.isTTY
 const originalEnv = { ...process.env }
@@ -15,6 +19,45 @@ vi.mock('./SyncSkills.js', async (importOriginal) => {
   return { ...actual, readHash: () => undefined }
 })
 
+function hasShell(shell: string): boolean {
+  return spawnSync(shell, ['-c', ':'], { stdio: 'ignore' }).status === 0
+}
+
+const bash = hasShell('bash')
+const zsh = hasShell('zsh')
+const fish = hasShell('fish')
+
+function exec(cmd: string, args: string[], env: NodeJS.ProcessEnv): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { env, timeout: 30_000 }, (error, stdout, stderr) => {
+      if (error) reject(new Error(stderr?.trim() || stdout?.trim() || error.message))
+      else resolve(stdout)
+    })
+  })
+}
+
+async function withFakeCli(run: (dir: string) => Promise<void>) {
+  const dir = await mkdtemp(join(tmpdir(), 'incur-completions-'))
+  const bin = join(dir, 'fake-cli')
+
+  try {
+    await writeFile(
+      bin,
+      `#!/bin/sh
+if [ -n "$COMPLETE" ]; then
+  printf '%s' "$COMPLETE:\${_COMPLETE_INDEX:-missing}"
+else
+  printf 'missing'
+fi
+`,
+    )
+    await chmod(bin, 0o755)
+    await run(dir)
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+}
+
 async function serve(
   cli: { serve: Cli.Cli['serve'] },
   argv: string[],
@@ -231,20 +274,59 @@ describe('register', () => {
   test('bash: generates complete -F script with nospace support', () => {
     const script = Completions.register('bash', 'mycli')
     expect(script).toContain('_incur_complete_mycli()')
-    expect(script).toContain('COMPLETE="bash"')
+    expect(script).toContain('export COMPLETE="bash"')
     expect(script).toContain('complete -o default -o bashdefault -o nosort -F')
     expect(script).toContain('"mycli" -- "${COMP_WORDS[@]}"')
     expect(script).toContain('compopt -o nospace')
   })
 
+  test.skipIf(!bash)('bash: exports completion env vars to the CLI subprocess', async () => {
+    await withFakeCli(async (dir) => {
+      const output = await exec(
+        'bash',
+        [
+          '-lc',
+          `${Completions.register('bash', 'fake-cli')}
+COMP_WORDS=('fake-cli' 'build' '')
+COMP_CWORD=2
+_incur_complete_fake_cli
+printf '%s' "\${COMPREPLY[*]}"`,
+        ],
+        { ...process.env, PATH: `${dir}:${process.env.PATH ?? ''}` },
+      )
+
+      expect(output).toBe('bash:2')
+    })
+  })
+
   test('zsh: generates compdef script', () => {
     const script = Completions.register('zsh', 'mycli')
     expect(script).toContain('#compdef mycli')
-    expect(script).toContain('COMPLETE="zsh"')
+    expect(script).toContain('export COMPLETE="zsh"')
     expect(script).toContain('compdef _incur_complete_mycli mycli')
     expect(script).toContain('_describe')
   })
 
+  test.skipIf(!zsh)('zsh: exports completion env vars to the CLI subprocess', async () => {
+    await withFakeCli(async (dir) => {
+      const output = await exec(
+        'zsh',
+        [
+          '-lc',
+          `compdef() { : }
+_describe() { print -r -- "\${(j:|:)\${(@P)2}}" }
+${Completions.register('zsh', 'fake-cli')}
+words=('fake-cli' 'build' '')
+CURRENT=3
+_incur_complete_fake_cli`,
+        ],
+        { ...process.env, PATH: `${dir}:${process.env.PATH ?? ''}` },
+      )
+
+      expect(output.trim()).toBe('zsh:2')
+    })
+  })
+
   test('fish: generates complete command', () => {
     const script = Completions.register('fish', 'mycli')
     expect(script).toContain('complete --keep-order --exclusive --command mycli')
@@ -252,6 +334,22 @@ describe('register', () => {
     expect(script).toContain('commandline --current-token')
   })
 
+  test.skipIf(!fish)('fish: passes completion env vars to the CLI subprocess', async () => {
+    await withFakeCli(async (dir) => {
+      const output = await exec(
+        'fish',
+        [
+          '-c',
+          `${Completions.register('fish', 'fake-cli')}
+complete --do-complete 'fake-cli '`,
+        ],
+        { ...process.env, PATH: `${dir}:${process.env.PATH ?? ''}` },
+      )
+
+      expect(output.trim()).toBe('fish:missing')
+    })
+  })
+
   test('nushell: generates external completer closure', () => {
     const script = Completions.register('nushell', 'mycli')
     expect(script).toContain('COMPLETE=nushell')
@@ -294,27 +392,24 @@ describe('completions built-in command', () => {
     expect(output).toMatchInlineSnapshot(`
       "mycli completions — Generate shell completion script
 
-      Usage: mycli completions <shell>
+      Usage: mycli completions <bash|fish|nushell|zsh>
 
-      Shells:
-        bash
-        fish
-        nushell
-        zsh
+      Arguments:
+        shell  Shell to generate completions for
 
       Setup:
         bash     eval "$(mycli completions bash)"  # add to ~/.bashrc
-        zsh      eval "$(mycli completions zsh)"   # add to ~/.zshrc
         fish     mycli completions fish | source   # add to ~/.config/fish/config.fish
         nushell  see \`mycli completions nushell\`   # add to config.nu
+        zsh      eval "$(mycli completions zsh)"   # add to ~/.zshrc
       "
     `)
   })
 
-  test('errors on missing shell argument', async () => {
+  test('shows help on missing shell argument', async () => {
     const cli = makeCli()
     const output = await serve(cli, ['completions'])
-    expect(output).toContain('Missing shell argument')
+    expect(output).toContain('Generate shell completion script')
   })
 
   test('errors on unknown shell', async () => {
@@ -391,9 +486,38 @@ describe('serve integration', () => {
     expect(output).toContain('db')
   })
 
+  test('COMPLETE=bash includes built-in commands at root', async () => {
+    const cli = makeCli()
+    const output = await serve(cli, ['--', 'mycli', ''], {
+      COMPLETE: 'bash',
+      _COMPLETE_INDEX: '1',
+    })
+    expect(output).toContain('completions')
+    expect(output).toContain('mcp')
+    expect(output).toContain('skills')
+  })
+
+  test('COMPLETE=bash suggests add for skills subcommand', async () => {
+    const cli = makeCli()
+    const output = await serve(cli, ['--', 'mycli', 'skills', ''], {
+      COMPLETE: 'bash',
+      _COMPLETE_INDEX: '2',
+    })
+    expect(output).toContain('add')
+  })
+
+  test('COMPLETE=bash suggests add for mcp subcommand', async () => {
+    const cli = makeCli()
+    const output = await serve(cli, ['--', 'mycli', 'mcp', ''], {
+      COMPLETE: 'bash',
+      _COMPLETE_INDEX: '2',
+    })
+    expect(output).toContain('add')
+  })
+
   test('COMPLETE=zsh with words outputs candidates in zsh format', async () => {
     const cli = makeCli()
-    const output = await serve(cli, ['--', 'mycli', '--'], {
+    await serve(cli, ['--', 'mycli', '--'], {
       COMPLETE: 'zsh',
       _COMPLETE_INDEX: '1',
     })

package/src/Completions.ts

@@ -1,7 +1,6 @@
 import type { z } from 'zod'
 
-/** Supported shells for completion generation. */
-export type Shell = 'bash' | 'fish' | 'nushell' | 'zsh'
+import type { Shell } from './internal/command.js'
 
 /** A completion candidate with an optional description. */
 export type Candidate = {
@@ -13,14 +12,16 @@ export type Candidate = {
   value: string
 }
 
-/** @internal Entry stored in a command map — either a leaf definition or a group. */
+/** @internal Entry stored in a command map — either a leaf definition, a group, or an alias. */
 type CommandEntry = {
+  _alias?: true | undefined
   _group?: true | undefined
   alias?: Record<string, string | undefined> | undefined
   args?: z.ZodObject<any> | undefined
   commands?: Map<string, CommandEntry> | undefined
   description?: string | undefined
   options?: z.ZodObject<any> | undefined
+  target?: string | undefined
 }
 
 /**
@@ -62,7 +63,10 @@ export function complete(
   for (let i = 0; i < index; i++) {
     const token = argv[i]!
     if (token.startsWith('-')) continue
-    const entry = scope.commands.get(token)
+    let entry = scope.commands.get(token)
+    if (!entry) continue
+    // Follow alias to canonical entry
+    if (entry._alias && entry.target) entry = scope.commands.get(entry.target)
     if (!entry) continue
     if (entry._group && entry.commands) {
       scope = { commands: entry.commands }
@@ -117,6 +121,7 @@ export function complete(
 
   // Suggest subcommands (groups get noSpace so user can keep typing subcommand)
   for (const [name, entry] of scope.commands) {
+    if (entry._alias) continue
     if (name.startsWith(current))
       candidates.push({
         value: name,
@@ -233,25 +238,25 @@ function bashRegister(name: string): string {
     local _COMPLETE_INDEX=\${COMP_CWORD}
     local _completions
     _completions=( $(
-        COMPLETE="bash"
-        _COMPLETE_INDEX="\$_COMPLETE_INDEX"
+        export COMPLETE="bash"
+        export _COMPLETE_INDEX="$_COMPLETE_INDEX"
         "${name}" -- "\${COMP_WORDS[@]}"
     ) )
-    if [[ \$? != 0 ]]; then
+    if [[ $? != 0 ]]; then
         unset COMPREPLY
         return
     fi
     local _nospace=false
     COMPREPLY=()
     for _c in "\${_completions[@]}"; do
-        if [[ "\$_c" == *$'\\001' ]]; then
+        if [[ "$_c" == *$'\\001' ]]; then
             _nospace=true
             COMPREPLY+=("\${_c%$'\\001'}")
         else
-            COMPREPLY+=("\$_c")
+            COMPREPLY+=("$_c")
         fi
     done
-    if [[ \$_nospace == true ]]; then
+    if [[ $_nospace == true ]]; then
         compopt -o nospace
     fi
 }
@@ -263,11 +268,11 @@ function zshRegister(name: string): string {
   return `#compdef ${name}
 _incur_complete_${id}() {
     local completions=("\${(@f)$(
-        _COMPLETE_INDEX=$(( CURRENT - 1 ))
-        COMPLETE="zsh"
+        export _COMPLETE_INDEX=$(( CURRENT - 1 ))
+        export COMPLETE="zsh"
         "${name}" -- "\${words[@]}" 2>/dev/null
     )}")
-    if [[ -n \$completions ]]; then
+    if [[ -n $completions ]]; then
         _describe 'values' completions -S ''
     fi
 }

package/src/Fetch.test.ts

@@ -82,6 +82,27 @@ describe('parseArgv', () => {
     expect(input.query.get('limit')).toBe('5')
   })
 
+  test('--method as last token throws missing value error', () => {
+    expect(() => Fetch.parseArgv(['users', '--method'])).toThrow('Missing value for --method')
+  })
+
+  test('-X as last token throws missing value error', () => {
+    expect(() => Fetch.parseArgv(['users', '-X'])).toThrow('Missing value for -X')
+  })
+
+  test('--header as last token throws missing value error', () => {
+    expect(() => Fetch.parseArgv(['users', '--header'])).toThrow('Missing value for --header')
+  })
+
+  test('--limit as last token throws missing value error', () => {
+    expect(() => Fetch.parseArgv(['users', '--limit'])).toThrow('Missing value for --limit')
+  })
+
+  test('unknown short flag does not swallow the next token', () => {
+    const input = Fetch.parseArgv(['users', '-z', 'create'])
+    expect(input.path).toBe('/users/create')
+  })
+
   test('mixed tokens, flags, and query params', () => {
     const input = Fetch.parseArgv([
       'users',

package/src/Fetch.ts

@@ -43,24 +43,22 @@ export function parseArgv(argv: string[]): FetchInput {
       } else {
         const key = token.slice(2)
         const value = argv[i + 1]
-        if (reservedFlags.has(key)) {
-          handleReserved(key, value!)
-          i += 2
-        } else {
-          query.set(key, value!)
-          i += 2
-        }
+        if (value === undefined) throw new Error(`Missing value for --${key}`)
+        if (reservedFlags.has(key)) handleReserved(key, value)
+        else query.set(key, value)
+        i += 2
       }
     } else if (token.startsWith('-') && token.length === 2) {
       const short = token[1]!
       const mapped = reservedShort[short]
-      const value = argv[i + 1]!
       if (mapped) {
+        const value = argv[i + 1]
+        if (value === undefined) throw new Error(`Missing value for -${short}`)
         handleReserved(mapped, value)
         i += 2
       } else {
-        // Unknown short flag — skip (shouldn't happen in fetch context)
-        i += 2
+        // Unknown short flag — treat as single token, don't consume next
+        i++
       }
     } else {
       segments.push(token)

package/src/Filter.ts

@@ -80,23 +80,6 @@ export function apply(data: unknown, paths: FilterPath[]): unknown {
   return result
 }
 
-function resolve(data: unknown, segments: Segment[], index: number): unknown {
-  if (index >= segments.length) return data
-  const segment = segments[index]!
-
-  if ('key' in segment) {
-    if (typeof data !== 'object' || data === null) return undefined
-    const val = (data as Record<string, unknown>)[segment.key]
-    return resolve(val, segments, index + 1)
-  }
-
-  // slice segment
-  if (!Array.isArray(data)) return undefined
-  const sliced = data.slice(segment.start, segment.end)
-  if (index + 1 >= segments.length) return sliced
-  return sliced.map((item) => resolve(item, segments, index + 1))
-}
-
 function merge(
   target: Record<string, unknown>,
   data: unknown,

package/src/Formatter.test.ts

@@ -296,8 +296,21 @@ describe('format md', () => {
 })
 
 describe('format jsonl', () => {
-  test('falls through to toon', () => {
+  test('single object outputs one JSON line', () => {
     const result = Formatter.format({ message: 'hello' }, 'jsonl')
-    expect(result).toMatchInlineSnapshot(`"message: hello"`)
+    expect(result).toMatchInlineSnapshot(`"{"message":"hello"}"`)
+  })
+
+  test('array outputs one JSON line per element', () => {
+    const result = Formatter.format([{ id: 1 }, { id: 2 }], 'jsonl')
+    expect(result).toMatchInlineSnapshot(`
+      "{"id":1}
+      {"id":2}"
+    `)
+  })
+
+  test('scalar value outputs JSON', () => {
+    expect(Formatter.format(42, 'jsonl')).toMatchInlineSnapshot(`"42"`)
+    expect(Formatter.format('hi', 'jsonl')).toMatchInlineSnapshot(`""hi""`)
   })
 })

package/src/Formatter.ts

@@ -10,7 +10,11 @@ export function format(value: unknown, fmt: Format = 'toon'): string {
   if (fmt === 'json') return JSON.stringify(value, null, 2)
   if (fmt === 'yaml') return yamlStringify(value)
   if (fmt === 'md') return formatMarkdown(value)
-  // toon
+  if (fmt === 'jsonl') {
+    if (Array.isArray(value)) return value.map((v) => JSON.stringify(v)).join('\n')
+    return JSON.stringify(value)
+  }
+  // toon (default)
   if (isScalar(value)) return String(value)
   return encode(value as Record<string, unknown>)
 }