incur 0.4.0 → 0.4.2

package/src/internal/command.ts

@@ -0,0 +1,449 @@
+import { z } from 'zod'
+
+import type { FieldError } from '../Errors.js'
+import { IncurError, ValidationError } from '../Errors.js'
+import type { Context as MiddlewareContext, Handler as MiddlewareHandler } from '../middleware.js'
+import * as Parser from '../Parser.js'
+
+/** @internal Sentinel symbol for `ok()` and `error()` return values. */
+const sentinel = Symbol.for('incur.sentinel')
+
+/** @internal CTA block for command output. */
+export type CtaBlock = {
+  commands: unknown[]
+  description?: string | undefined
+}
+
+/** @internal A tagged ok result. */
+type OkResult = {
+  [sentinel]: 'ok'
+  data: unknown
+  cta?: CtaBlock | undefined
+}
+
+/** @internal A tagged error result. */
+type ErrorResult = {
+  [sentinel]: 'error'
+  code: string
+  message: string
+  retryable?: boolean | undefined
+  exitCode?: number | undefined
+  cta?: CtaBlock | undefined
+}
+
+/** @internal Unified command execution used by CLI, HTTP, and MCP transports. */
+export async function execute(command: any, options: execute.Options): Promise<execute.Result> {
+  const {
+    argv,
+    inputOptions,
+    agent,
+    format,
+    formatExplicit,
+    name,
+    path,
+    version,
+    envSource = process.env,
+    env: envSchema,
+    vars: varsSchema,
+    middlewares = [],
+  } = options
+  const displayName = options.displayName ?? name
+  const parseMode = options.parseMode ?? 'argv'
+
+  const varsMap: Record<string, unknown> = varsSchema ? varsSchema.parse({}) : {}
+  let result: execute.Result | undefined
+  // For streaming with middleware: runCommand suspends on streamConsumed so middleware "after"
+  // runs after the stream is consumed. The wrapped generator resolves it in its finally block.
+  // resultReady signals that result has been set (for streams, before the chain finishes).
+  let streamConsumed: Promise<void> | undefined
+  let resolveStreamConsumed: (() => void) | undefined
+  let resolveResultReady: (() => void) | undefined
+  const resultReady = new Promise<void>((r) => {
+    resolveResultReady = r
+  })
+
+  const runCommand = async () => {
+    // Parse args and options
+    let args: Record<string, unknown>
+    let parsedOptions: Record<string, unknown>
+
+    if (parseMode === 'argv') {
+      // CLI mode: parse both args and options from argv tokens
+      const parsed = Parser.parse(argv, {
+        alias: command.alias as Record<string, string> | undefined,
+        args: command.args,
+        defaults: options.defaults,
+        options: command.options,
+      })
+      args = parsed.args
+      parsedOptions = parsed.options
+    } else if (parseMode === 'split') {
+      // HTTP mode: positional args from URL path segments, options from body/query
+      const parsed = Parser.parse(argv, { args: command.args })
+      args = parsed.args
+      parsedOptions = command.options ? command.options.parse(inputOptions) : {}
+    } else {
+      // MCP mode: all params come from inputOptions, split into args vs options
+      const split = splitParams(inputOptions, command)
+      args = command.args ? command.args.parse(split.args) : {}
+      parsedOptions = command.options ? command.options.parse(split.options) : {}
+    }
+
+    // Parse env
+    const commandEnv = command.env ? Parser.parseEnv(command.env, envSource) : {}
+
+    // Build sentinel helpers
+    const okFn = (data: unknown, meta: { cta?: CtaBlock | undefined } = {}): never =>
+      ({ [sentinel]: 'ok', data, cta: meta.cta }) as never
+    const errorFn = (opts: {
+      code: string
+      cta?: CtaBlock | undefined
+      exitCode?: number | undefined
+      message: string
+      retryable?: boolean | undefined
+    }): never => ({ [sentinel]: 'error', ...opts }) as never
+
+    const raw = command.run({
+      agent,
+      args,
+      displayName,
+      env: commandEnv,
+      error: errorFn,
+      format,
+      formatExplicit,
+      name,
+      ok: okFn,
+      options: parsedOptions,
+      var: varsMap,
+      version,
+    })
+
+    // Streaming: wrap the generator so middleware "after" runs after consumption.
+    // When middleware is active, runCommand suspends until the stream is fully consumed,
+    // keeping the middleware chain alive around the stream's lifetime.
+    if (isAsyncGenerator(raw)) {
+      if (middlewares.length > 0) {
+        streamConsumed = new Promise<void>((r) => {
+          resolveStreamConsumed = r
+        })
+        async function* wrapped() {
+          try {
+            yield* raw as AsyncGenerator<unknown, unknown, unknown>
+          } finally {
+            resolveStreamConsumed!()
+          }
+        }
+        result = { stream: wrapped() }
+        resolveResultReady!()
+        await streamConsumed
+      } else {
+        result = { stream: raw }
+      }
+      return
+    }
+
+    const awaited = await raw
+
+    if (isSentinel(awaited)) {
+      if (awaited[sentinel] === 'ok') {
+        const ok = awaited as OkResult
+        result = { ok: true, data: ok.data, ...(ok.cta ? { cta: ok.cta } : undefined) }
+      } else {
+        const err = awaited as ErrorResult
+        result = {
+          ok: false,
+          error: {
+            code: err.code,
+            message: err.message,
+            ...(err.retryable !== undefined ? { retryable: err.retryable } : undefined),
+          },
+          ...(err.cta ? { cta: err.cta } : undefined),
+          ...(err.exitCode !== undefined ? { exitCode: err.exitCode } : undefined),
+        }
+      }
+      return
+    }
+
+    result = { ok: true, data: awaited }
+  }
+
+  try {
+    // Parse CLI-level env
+    const cliEnv = envSchema ? Parser.parseEnv(envSchema, envSource) : {}
+
+    if (middlewares.length > 0) {
+      const errorFn = (opts: {
+        code: string
+        cta?: CtaBlock | undefined
+        exitCode?: number | undefined
+        message: string
+        retryable?: boolean | undefined
+      }): never => {
+        // Side-effect: set result directly (handles both `return c.error()` and bare `c.error()`)
+        result = {
+          ok: false,
+          error: {
+            code: opts.code,
+            message: opts.message,
+            ...(opts.retryable !== undefined ? { retryable: opts.retryable } : undefined),
+          },
+          ...(opts.cta ? { cta: opts.cta } : undefined),
+          ...(opts.exitCode !== undefined ? { exitCode: opts.exitCode } : undefined),
+        }
+        return undefined as never
+      }
+
+      const mwCtx: MiddlewareContext = {
+        agent,
+        command: path,
+        displayName,
+        env: cliEnv,
+        error: errorFn,
+        format: format as any,
+        formatExplicit,
+        name,
+        set(key: string, value: unknown) {
+          varsMap[key] = value
+        },
+        var: varsMap,
+        version,
+      }
+
+      const composed = middlewares.reduceRight(
+        (next: () => Promise<void>, mw) => async () => {
+          await mw(mwCtx, next)
+        },
+        runCommand,
+      )
+      // Start the chain and race against resultReady. For streams with middleware,
+      // runCommand suspends on streamConsumed (keeping middleware "after" deferred)
+      // but signals resultReady so we can return the stream immediately. The transport
+      // consumes the stream, which resolves streamConsumed, letting middleware "after" run.
+      const chainPromise = composed()
+      await Promise.race([chainPromise, resultReady])
+      if (streamConsumed) return result!
+      await chainPromise
+    } else {
+      await runCommand()
+    }
+  } catch (error) {
+    if (error instanceof ValidationError)
+      return {
+        ok: false,
+        error: {
+          code: 'VALIDATION_ERROR',
+          message: error.message,
+          fieldErrors: error.fieldErrors,
+        },
+      }
+    return {
+      ok: false,
+      error: {
+        code: error instanceof IncurError ? error.code : 'UNKNOWN',
+        message: error instanceof Error ? error.message : String(error),
+        ...(error instanceof IncurError ? { retryable: error.retryable } : undefined),
+      },
+      ...(error instanceof IncurError && error.exitCode !== undefined
+        ? { exitCode: error.exitCode }
+        : undefined),
+    }
+  }
+
+  return result ?? { ok: true, data: undefined }
+}
+
+/** @internal Splits flat params into args vs options using schema shapes. */
+function splitParams(
+  params: Record<string, unknown>,
+  command: any,
+): { args: Record<string, unknown>; options: Record<string, unknown> } {
+  const argKeys = new Set(command.args ? Object.keys(command.args.shape) : [])
+  const a: Record<string, unknown> = {}
+  const o: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(params))
+    if (argKeys.has(key)) a[key] = value
+    else o[key] = value
+  return { args: a, options: o }
+}
+
+export declare namespace execute {
+  /** Options for the unified execute function. */
+  type Options = {
+    /** Whether the consumer is an agent. */
+    agent: boolean
+    /** Raw positional tokens (already separated from flags). For HTTP/MCP, pass `[]`. */
+    argv: string[]
+    /** Default option values from config file. */
+    defaults?: Record<string, unknown> | undefined
+    /** The resolved binary name the user invoked (e.g. an alias). Falls back to `name`. */
+    displayName?: string | undefined
+    /** CLI-level env schema. */
+    env?: z.ZodObject<any> | undefined
+    /** Source for environment variables. Defaults to `process.env`. */
+    envSource?: Record<string, string | undefined> | undefined
+    /** The resolved output format. */
+    format: string
+    /** Whether the format was explicitly requested. */
+    formatExplicit: boolean
+    /** Raw parsed options (from query params, JSON body, or MCP params). For CLI, pass `{}`. */
+    inputOptions: Record<string, unknown>
+    /** Middleware handlers (root + group + command, already collected). */
+    middlewares?: MiddlewareHandler[] | undefined
+    /** The CLI name. */
+    name: string
+    /**
+     * How to parse input:
+     * - `'argv'` (default): parse both args and options from argv tokens (CLI mode)
+     * - `'split'`: args from argv, options from inputOptions (HTTP mode)
+     * - `'flat'`: all params from inputOptions, split by schema shapes (MCP mode)
+     */
+    parseMode?: 'argv' | 'split' | 'flat' | undefined
+    /** The resolved command path. */
+    path: string
+    /** Vars schema for middleware variables. */
+    vars?: z.ZodObject<any> | undefined
+    /** CLI version string. */
+    version: string | undefined
+  }
+
+  /** Result of executing a command. */
+  type Result =
+    | { ok: true; data: unknown; cta?: CtaBlock | undefined }
+    | {
+        ok: false
+        error: {
+          code: string
+          message: string
+          retryable?: boolean | undefined
+          fieldErrors?: FieldError[] | undefined
+        }
+        cta?: CtaBlock | undefined
+        exitCode?: number | undefined
+      }
+    | { stream: AsyncGenerator<unknown, unknown, unknown> }
+}
+
+/** @internal Type guard for sentinel results. */
+function isSentinel(value: unknown): value is OkResult | ErrorResult {
+  return typeof value === 'object' && value !== null && sentinel in value
+}
+
+/** @internal Type guard for async generators. */
+function isAsyncGenerator(value: unknown): value is AsyncGenerator<unknown, unknown, unknown> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    Symbol.asyncIterator in value &&
+    typeof (value as any).next === 'function'
+  )
+}
+
+/** Common metadata shared by command definitions and built-in commands. */
+export type CommandMeta<options extends z.ZodObject<any> | undefined = undefined> = {
+  /** Map of option names to single-char aliases. */
+  alias?: options extends z.ZodObject<any>
+    ? Partial<Record<keyof z.output<options>, string>>
+    : Record<string, string> | undefined
+  /** A short description of what the command does. */
+  description?: string | undefined
+  /** Zod schema for named options/flags. */
+  options?: options | undefined
+}
+
+/** @internal Creates a builtin subcommand with typesafe alias inference. */
+function subcommand<const options extends z.ZodObject<any> | undefined = undefined>(
+  def: CommandMeta<options> & { name: string },
+) {
+  return def
+}
+
+/** Supported shell names for completions. */
+export const shells = ['bash', 'fish', 'nushell', 'zsh'] as const
+
+/** A supported shell name. */
+export type Shell = (typeof shells)[number]
+
+/** Built-in command metadata shared by help, completions, and handler logic. */
+export const builtinCommands = [
+  {
+    name: 'completions',
+    description: 'Generate shell completion script',
+    args: z.object({
+      shell: z.enum(shells).describe('Shell to generate completions for'),
+    }),
+    hint(name) {
+      const rows = [
+        ['bash', `eval "$(${name} completions bash)"`, '# add to ~/.bashrc'],
+        ['fish', `${name} completions fish | source`, '# add to ~/.config/fish/config.fish'],
+        ['nushell', `see \`${name} completions nushell\``, '# add to config.nu'],
+        ['zsh', `eval "$(${name} completions zsh)"`, '# add to ~/.zshrc'],
+      ] as const
+      const shellW = Math.max(...rows.map((r) => r[0].length))
+      const cmdW = Math.max(...rows.map((r) => r[1].length))
+      return (
+        'Setup:\n' +
+        rows
+          .map(([s, cmd, comment]) => `  ${s.padEnd(shellW)}  ${cmd.padEnd(cmdW)}  ${comment}`)
+          .join('\n')
+      )
+    },
+  },
+  {
+    name: 'mcp',
+    description: 'Register as MCP server',
+    subcommands: [
+      subcommand({
+        name: 'add',
+        description: 'Register as MCP server',
+        alias: { command: 'c' },
+        options: z.object({
+          agent: z
+            .string()
+            .optional()
+            .describe('Target a specific agent (e.g. claude-code, cursor)'),
+          command: z
+            .string()
+            .optional()
+            .describe('Override the command agents will run (e.g. "pnpm my-cli --mcp")'),
+          noGlobal: z.boolean().optional().describe('Install to project instead of globally'),
+        }),
+      }),
+    ],
+  },
+  {
+    name: 'skills',
+    aliases: ['skill'],
+    description: 'Sync skill files to agents',
+    subcommands: [
+      subcommand({
+        name: 'add',
+        description: 'Sync skill files to agents',
+        options: z.object({
+          depth: z.number().optional().describe('Grouping depth for skill files (default: 1)'),
+          noGlobal: z.boolean().optional().describe('Install to project instead of globally'),
+        }),
+      }),
+      subcommand({
+        name: 'list',
+        description: 'List skills',
+      }),
+    ],
+  },
+] satisfies {
+  name: string
+  aliases?: string[] | undefined
+  args?: z.ZodObject<any> | undefined
+  description: string
+  hint?: ((name: string) => string) | undefined
+  subcommands?: (CommandMeta<z.ZodObject<any>> & { name: string })[] | undefined
+}[]
+
+/** @internal Finds a builtin command by its name or alias. */
+export function findBuiltin(token: string) {
+  return builtinCommands.find((b) => b.name === token || b.aliases?.includes(token))
+}
+
+/** @internal Checks if a token matches a builtin command by name or alias. */
+export function isBuiltin(token: string) {
+  return builtinCommands.some((b) => b.name === token || b.aliases?.includes(token))
+}

package/src/internal/configSchema.test.ts

@@ -0,0 +1,193 @@
+import { Cli, z } from 'incur'
+
+import * as ConfigSchema from './configSchema.js'
+
+describe('fromCli', () => {
+  test('generates schema for root options and leaf commands', () => {
+    const cli = Cli.create('test', {
+      options: z.object({
+        verbose: z.boolean().default(false),
+      }),
+    })
+    cli.command('echo', {
+      options: z.object({
+        prefix: z.string().default(''),
+        upper: z.boolean().default(false),
+      }),
+      run: (c) => c.options,
+    })
+
+    const schema = ConfigSchema.fromCli(cli)
+    expect(schema).toMatchInlineSnapshot(`
+      {
+        "additionalProperties": false,
+        "properties": {
+          "$schema": {
+            "type": "string",
+          },
+          "commands": {
+            "additionalProperties": false,
+            "properties": {
+              "echo": {
+                "additionalProperties": false,
+                "properties": {
+                  "options": {
+                    "additionalProperties": false,
+                    "properties": {
+                      "prefix": {
+                        "default": "",
+                        "type": "string",
+                      },
+                      "upper": {
+                        "default": false,
+                        "type": "boolean",
+                      },
+                    },
+                    "type": "object",
+                  },
+                },
+                "type": "object",
+              },
+            },
+            "type": "object",
+          },
+          "options": {
+            "additionalProperties": false,
+            "properties": {
+              "verbose": {
+                "default": false,
+                "type": "boolean",
+              },
+            },
+            "type": "object",
+          },
+        },
+        "type": "object",
+      }
+    `)
+  })
+
+  test('generates schema for nested command groups', () => {
+    const project = Cli.create('project')
+    project.command('list', {
+      options: z.object({
+        limit: z.number().default(10),
+        label: z.array(z.string()).default([]),
+      }),
+      run: (c) => c.options,
+    })
+
+    const cli = Cli.create('test')
+    cli.command(project)
+
+    const schema = ConfigSchema.fromCli(cli)
+    expect(schema).toMatchInlineSnapshot(`
+      {
+        "additionalProperties": false,
+        "properties": {
+          "$schema": {
+            "type": "string",
+          },
+          "commands": {
+            "additionalProperties": false,
+            "properties": {
+              "project": {
+                "additionalProperties": false,
+                "properties": {
+                  "commands": {
+                    "additionalProperties": false,
+                    "properties": {
+                      "list": {
+                        "additionalProperties": false,
+                        "properties": {
+                          "options": {
+                            "additionalProperties": false,
+                            "properties": {
+                              "label": {
+                                "default": [],
+                                "items": {
+                                  "type": "string",
+                                },
+                                "type": "array",
+                              },
+                              "limit": {
+                                "default": 10,
+                                "type": "number",
+                              },
+                            },
+                            "type": "object",
+                          },
+                        },
+                        "type": "object",
+                      },
+                    },
+                    "type": "object",
+                  },
+                },
+                "type": "object",
+              },
+            },
+            "type": "object",
+          },
+        },
+        "type": "object",
+      }
+    `)
+  })
+
+  test('returns schema with only $schema for cli with no commands', () => {
+    const cli = Cli.create('test')
+    const schema = ConfigSchema.fromCli(cli)
+    expect(schema).toEqual({
+      type: 'object',
+      additionalProperties: false,
+      properties: { $schema: { type: 'string' } },
+    })
+  })
+
+  test('skips fetch gateway commands', () => {
+    const cli = Cli.create('test')
+    cli.command('echo', {
+      options: z.object({ prefix: z.string().default('') }),
+      run: (c) => c.options,
+    })
+    cli.command('api', {
+      description: 'API gateway',
+      fetch: () => new Response('ok'),
+    })
+
+    const schema = ConfigSchema.fromCli(cli)
+    const commandKeys = Object.keys((schema as any).properties.commands.properties)
+    expect(commandKeys).toEqual(['echo'])
+  })
+
+  test('includes commands without options as empty objects', () => {
+    const cli = Cli.create('test')
+    cli.command('ping', {
+      run: () => 'pong',
+    })
+
+    const schema = ConfigSchema.fromCli(cli)
+    expect(schema).toMatchInlineSnapshot(`
+      {
+        "additionalProperties": false,
+        "properties": {
+          "$schema": {
+            "type": "string",
+          },
+          "commands": {
+            "additionalProperties": false,
+            "properties": {
+              "ping": {
+                "additionalProperties": false,
+                "type": "object",
+              },
+            },
+            "type": "object",
+          },
+        },
+        "type": "object",
+      }
+    `)
+  })
+})

package/src/internal/configSchema.ts

@@ -0,0 +1,66 @@
+import fs from 'node:fs/promises'
+import type { z } from 'zod'
+
+import * as Cli from '../Cli.js'
+import * as Schema from '../Schema.js'
+import { importCli } from './utils.js'
+
+/** Returns `true` if the CLI has `config` enabled on `Cli.create()`. */
+export function hasConfig(cli: Cli.Cli): boolean {
+  return Cli.toConfigEnabled.get(cli) === true
+}
+
+/** Imports a CLI from `input` (must `export default` a `Cli`), generates the JSON Schema, and writes it to `output`. */
+export async function generate(input: string, output: string): Promise<void> {
+  const cli = await importCli(input)
+  await fs.writeFile(output, JSON.stringify(fromCli(cli), null, 2) + '\n')
+}
+
+/** Generates a JSON Schema describing the config file structure for a CLI. */
+export function fromCli(cli: Cli.Cli): Record<string, unknown> {
+  const commands = Cli.toCommands.get(cli)
+  if (!commands) return { type: 'object' }
+
+  const rootOptions = Cli.toRootOptions.get(cli)
+  const node = buildNode(commands, rootOptions)
+  const properties = (node.properties ?? {}) as Record<string, unknown>
+  properties.$schema = { type: 'string' }
+  node.properties = properties
+  return node
+}
+
+/** Builds a JSON Schema node for a command level. */
+function buildNode(
+  commands: Map<string, any>,
+  options?: z.ZodObject<any>,
+): Record<string, unknown> {
+  const properties: Record<string, unknown> = {}
+
+  // Add `options` property from the options schema
+  if (options) {
+    const optSchema = Schema.toJsonSchema(options)
+    const props = optSchema.properties as Record<string, unknown> | undefined
+    if (props && Object.keys(props).length > 0)
+      properties.options = { type: 'object', additionalProperties: false, properties: props }
+  }
+
+  // Add `commands` property with subcommand namespaces
+  const commandProps: Record<string, unknown> = {}
+  for (const [name, entry] of commands) {
+    if ('_group' in entry && entry._group) {
+      commandProps[name] = buildNode(entry.commands, undefined)
+    } else if (!('_fetch' in entry)) {
+      const cmd = entry as { options?: z.ZodObject<any> }
+      commandProps[name] = buildNode(new Map(), cmd.options)
+    }
+  }
+  if (Object.keys(commandProps).length > 0)
+    properties.commands = { type: 'object', additionalProperties: false, properties: commandProps }
+
+  const node: Record<string, unknown> = {
+    type: 'object',
+    additionalProperties: false,
+  }
+  if (Object.keys(properties).length > 0) node.properties = properties
+  return node
+}