incur 0.3.4 → 0.3.6

package/src/Mcp.ts

@@ -1,7 +1,10 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import type { Readable, Writable } from 'node:stream'
+import type { z } from 'zod'
 
+import * as Command from './internal/command.js'
+import type { Handler as MiddlewareHandler } from './middleware.js'
 import * as Schema from './Schema.js'
 
 /** Starts a stdio MCP server that exposes commands as tools. */
@@ -25,12 +28,20 @@ export async function serve(
       {
         ...(tool.description ? { description: tool.description } : undefined),
         ...(hasInput ? { inputSchema: mergedShape } : undefined),
-      },
+        ...(tool.outputSchema ? { outputSchema: tool.outputSchema } : undefined),
+      } as never,
       async (...callArgs: any[]) => {
         // registerTool passes (args, extra) when inputSchema is set, (extra) when not
         const params = hasInput ? (callArgs[0] as Record<string, unknown>) : {}
         const extra = hasInput ? callArgs[1] : callArgs[0]
-        return callTool(tool, params, extra)
+        return callTool(tool, params, {
+          extra,
+          name,
+          version,
+          middlewares: options.middlewares,
+          env: options.env,
+          vars: options.vars,
+        })
       },
     )
   }
@@ -44,10 +55,18 @@ export async function serve(
 export declare namespace serve {
   /** Options for the MCP server. */
   type Options = {
+    /** CLI-level env schema. */
+    env?: z.ZodObject<any> | undefined
     /** Override input stream. Defaults to `process.stdin`. */
     input?: Readable | undefined
+    /** Middleware handlers registered on the root CLI. */
+    middlewares?: MiddlewareHandler[] | undefined
     /** Override output stream. Defaults to `process.stdout`. */
     output?: Writable | undefined
+    /** Vars schema for middleware variables. */
+    vars?: z.ZodObject<any> | undefined
+    /** CLI version string. */
+    version?: string | undefined
   }
 }
 
@@ -55,83 +74,73 @@ export declare namespace serve {
 export async function callTool(
   tool: ToolEntry,
   params: Record<string, unknown>,
-  extra?: {
-    _meta?: { progressToken?: string | number }
-    sendNotification?: (n: any) => Promise<void>
-  },
-): Promise<{ content: { type: 'text'; text: string }[]; isError?: boolean }> {
-  try {
-    const { args, options } = splitParams(params, tool.command)
-    const parsedArgs = tool.command.args ? tool.command.args.parse(args) : {}
-    const parsedOptions = tool.command.options ? tool.command.options.parse(options) : {}
-    const parsedEnv = tool.command.env ? tool.command.env.parse(process.env) : {}
-
-    const sentinel = Symbol.for('incur.sentinel')
-    const okFn = (data: unknown): never => ({ [sentinel]: 'ok', data }) as never
-    const errorFn = (opts: { code: string; message: string }): never =>
-      ({ [sentinel]: 'error', ...opts }) as never
-
-    const raw = tool.command.run({
-      args: parsedArgs,
-      env: parsedEnv,
-      options: parsedOptions,
-      ok: okFn,
-      error: errorFn,
-    })
-
+  options: {
+    extra?: {
+      _meta?: { progressToken?: string | number }
+      sendNotification?: (n: any) => Promise<void>
+    }
+    name?: string | undefined
+    version?: string | undefined
+    middlewares?: MiddlewareHandler[] | undefined
+    env?: z.ZodObject<any> | undefined
+    vars?: z.ZodObject<any> | undefined
+  } = {},
+): Promise<{ content: { type: 'text'; text: string }[]; structuredContent?: Record<string, unknown>; isError?: boolean }> {
+  const allMiddleware = [
+    ...(options.middlewares ?? []),
+    ...((tool.middlewares as MiddlewareHandler[] | undefined) ?? []),
+    ...((tool.command.middleware as MiddlewareHandler[] | undefined) ?? []),
+  ]
+
+  const result = await Command.execute(tool.command, {
+    agent: true,
+    argv: [],
+    env: options.env,
+    format: 'json',
+    formatExplicit: true,
+    inputOptions: params,
+    middlewares: allMiddleware,
+    name: options.name ?? tool.name,
+    parseMode: 'flat',
+    path: tool.name,
+    vars: options.vars,
+    version: options.version,
+  })
+
+  if ('stream' in result) {
     // Streaming: send progress notifications per chunk, then return buffered result
-    if (isAsyncGenerator(raw)) {
-      const chunks: unknown[] = []
-      const progressToken = extra?._meta?.progressToken
-      let i = 0
-      for await (const chunk of raw) {
-        if (typeof chunk === 'object' && chunk !== null && sentinel in chunk) {
-          const tagged = chunk as any
-          if (tagged[sentinel] === 'error')
-            return {
-              content: [{ type: 'text', text: tagged.message ?? 'Command failed' }],
-              isError: true,
-            }
-        }
+    const chunks: unknown[] = []
+    const progressToken = options.extra?._meta?.progressToken
+    let i = 0
+    try {
+      for await (const chunk of result.stream) {
         chunks.push(chunk)
-        if (progressToken !== undefined && extra?.sendNotification)
-          await extra.sendNotification({
+        if (progressToken !== undefined && options.extra?.sendNotification)
+          await options.extra.sendNotification({
             method: 'notifications/progress' as const,
             params: { progressToken, progress: ++i, message: JSON.stringify(chunk) },
           })
       }
-      return { content: [{ type: 'text', text: JSON.stringify(chunks) }] }
-    }
-
-    const awaited = await raw
-
-    if (typeof awaited === 'object' && awaited !== null && sentinel in awaited) {
-      const tagged = awaited as any
-      if (tagged[sentinel] === 'error')
-        return {
-          content: [{ type: 'text', text: tagged.message ?? 'Command failed' }],
-          isError: true,
-        }
-      return { content: [{ type: 'text', text: JSON.stringify(tagged.data ?? null) }] }
+    } catch (err) {
+      return {
+        content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
+        isError: true,
+      }
     }
+    return { content: [{ type: 'text', text: JSON.stringify(chunks) }] }
+  }
 
-    return { content: [{ type: 'text', text: JSON.stringify(awaited ?? null) }] }
-  } catch (err) {
+  if (!result.ok)
     return {
-      content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
+      content: [{ type: 'text', text: result.error.message ?? 'Command failed' }],
       isError: true,
     }
-  }
-}
 
-/** @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'
-  )
+  const data = result.data ?? null
+  return {
+    content: [{ type: 'text', text: JSON.stringify(data) }],
+    ...(data !== null && tool.outputSchema ? { structuredContent: data as Record<string, unknown> } : undefined),
+  }
 }
 
 /** @internal A resolved tool entry from the command tree. */
@@ -139,21 +148,34 @@ export type ToolEntry = {
   name: string
   description?: string | undefined
   inputSchema: { type: 'object'; properties: Record<string, unknown>; required?: string[] }
+  outputSchema?: Record<string, unknown> | undefined
   command: any
+  middlewares?: MiddlewareHandler[] | undefined
 }
 
 /** @internal Recursively collects leaf commands as tool entries. */
-export function collectTools(commands: Map<string, any>, prefix: string[]): ToolEntry[] {
+export function collectTools(
+  commands: Map<string, any>,
+  prefix: string[],
+  parentMiddlewares: MiddlewareHandler[] = [],
+): ToolEntry[] {
   const result: ToolEntry[] = []
   for (const [name, entry] of commands) {
     const path = [...prefix, name]
-    if ('_group' in entry && entry._group) result.push(...collectTools(entry.commands, path))
-    else {
+    if ('_group' in entry && entry._group) {
+      const groupMw = [
+        ...parentMiddlewares,
+        ...((entry.middlewares as MiddlewareHandler[] | undefined) ?? []),
+      ]
+      result.push(...collectTools(entry.commands, path, groupMw))
+    } else {
       result.push({
         name: path.join('_'),
         description: entry.description,
         inputSchema: buildToolSchema(entry.args, entry.options),
+        ...(entry.output ? { outputSchema: Schema.toJsonSchema(entry.output) as Record<string, unknown> } : undefined),
         command: entry,
+        ...(parentMiddlewares.length > 0 ? { middlewares: parentMiddlewares } : undefined),
       })
     }
   }
@@ -179,17 +201,3 @@ function buildToolSchema(
   return { type: 'object', properties }
 }
 
-/** @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 }
-}

package/src/Parser.test-d.ts

@@ -43,3 +43,25 @@ test('narrows both args and options together', () => {
   expectTypeOf(result.args).toEqualTypeOf<{ repo: string }>()
   expectTypeOf(result.options).toEqualTypeOf<{ limit: number }>()
 })
+
+test('defaults are typed from z.input of the options schema', () => {
+  const result = Parser.parse([], {
+    defaults: { limit: '5' },
+    options: z.object({ limit: z.coerce.number().default(30) }),
+  })
+  expectTypeOf(result.options).toEqualTypeOf<{ limit: number }>()
+})
+
+test('defaults do not leak any', () => {
+  type Options = z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>
+    saveDev: z.ZodOptional<z.ZodBoolean>
+  }>
+
+  expectTypeOf<Parser.parse.Options<undefined, Options>>().toEqualTypeOf<{
+    args?: undefined
+    alias?: Record<string, string> | undefined
+    defaults?: Partial<z.input<Options>> | undefined
+    options?: Options
+  }>()
+})

package/src/Parser.test.ts

@@ -252,4 +252,93 @@ describe('parse', () => {
     expect(result.args).toEqual({ repo: 'myrepo' })
     expect(result.options).toEqual({ limit: 5 })
   })
+
+  test('applies config defaults when argv omits an option', () => {
+    const result = Parser.parse([], {
+      defaults: { limit: 10 },
+      options: z.object({ limit: z.number().default(30) }),
+    })
+    expect(result.options).toEqual({ limit: 10 })
+  })
+
+  test('argv overrides config defaults', () => {
+    const result = Parser.parse(['--limit', '5'], {
+      defaults: { limit: 10 },
+      options: z.object({ limit: z.number().default(30) }),
+    })
+    expect(result.options).toEqual({ limit: 5 })
+  })
+
+  test('argv arrays replace config arrays', () => {
+    const result = Parser.parse(['--label', 'bug', '--label', 'feature'], {
+      defaults: { label: ['ops'] },
+      options: z.object({ label: z.array(z.string()).default([]) }),
+    })
+    expect(result.options).toEqual({ label: ['bug', 'feature'] })
+  })
+
+  test('kebab-case config keys map to camelCase schema names', () => {
+    const result = Parser.parse([], {
+      defaults: { 'save-dev': true } as any,
+      options: z.object({ saveDev: z.boolean().default(false) }),
+    })
+    expect(result.options).toEqual({ saveDev: true })
+  })
+
+  test('throws ParseError on unknown config option keys', () => {
+    expect(() =>
+      Parser.parse([], {
+        defaults: { missing: true } as any,
+        options: z.object({ saveDev: z.boolean().default(false) }),
+      }),
+    ).toThrow(expect.objectContaining({ name: 'Incur.ParseError' }))
+  })
+
+  test('throws ValidationError for invalid config defaults when argv does not override them', () => {
+    expect(() =>
+      Parser.parse([], {
+        defaults: { limit: 'oops' } as any,
+        options: z.object({ limit: z.number() }),
+      }),
+    ).toThrow(expect.objectContaining({ name: 'Incur.ValidationError' }))
+  })
+
+  test('argv overrides invalid config defaults', () => {
+    const result = Parser.parse(['--limit', '5'], {
+      defaults: { limit: 'oops' } as any,
+      options: z.object({ limit: z.number() }),
+    })
+    expect(result.options).toEqual({ limit: 5 })
+  })
+
+  test('defaults with no options schema throws on non-empty defaults', () => {
+    expect(() =>
+      Parser.parse([], {
+        defaults: { limit: 10 } as any,
+      }),
+    ).toThrow(expect.objectContaining({ name: 'Incur.ParseError' }))
+  })
+
+  test('defaults with no options schema and empty defaults is a no-op', () => {
+    const result = Parser.parse([], { defaults: {} as any })
+    expect(result.options).toEqual({})
+  })
+
+  test('config array defaults are used when argv omits the option', () => {
+    const result = Parser.parse([], {
+      defaults: { label: ['bug', 'feature'] },
+      options: z.object({ label: z.array(z.string()).default([]) }),
+    })
+    expect(result.options).toEqual({ label: ['bug', 'feature'] })
+  })
+
+  test('refined option schemas validate only the merged winning values', () => {
+    const result = Parser.parse(['--min', '1', '--max', '3'], {
+      defaults: { min: 'oops' } as any,
+      options: z
+        .object({ min: z.number(), max: z.number() })
+        .refine((value) => value.min < value.max, { message: 'min must be less than max' }),
+    })
+    expect(result.options).toEqual({ min: 1, max: 3 })
+  })
 })

package/src/Parser.ts

@@ -2,29 +2,20 @@ import type { z } from 'zod'
 
 import type { FieldError } from './Errors.js'
 import { ParseError, ValidationError } from './Errors.js'
+import { isRecord, toKebab } from './internal/helpers.js'
 
 /** Parses raw argv tokens against Zod schemas for args and options. */
 export function parse<
   const args extends z.ZodObject<any> | undefined = undefined,
   const options extends z.ZodObject<any> | undefined = undefined,
 >(argv: string[], options: parse.Options<args, options> = {}): parse.ReturnType<args, options> {
-  const { args: argsSchema, options: optionsSchema, alias } = options
+  const { args: argsSchema, options: optionsSchema, alias, defaults } = options
 
-  // Build reverse alias map: short char → long name
-  const aliasToName = new Map<string, string>()
-  if (alias) for (const [name, short] of Object.entries(alias)) aliasToName.set(short, name)
-
-  // Known option names from schema, plus kebab-case → camelCase map
-  const knownOptions = new Set(optionsSchema ? Object.keys(optionsSchema.shape) : [])
-  const kebabToCamel = new Map<string, string>()
-  for (const name of knownOptions) {
-    const kebab = name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)
-    if (kebab !== name) kebabToCamel.set(kebab, name)
-  }
+  const optionNames = createOptionNames(optionsSchema, alias)
 
   // First pass: split argv into positional tokens and raw option values
   const positionals: string[] = []
-  const rawOptions: Record<string, unknown> = {}
+  const rawArgvOptions: Record<string, unknown> = {}
 
   let i = 0
   while (i < argv.length) {
@@ -32,36 +23,34 @@ export function parse<
 
     if (token.startsWith('--no-') && token.length > 5) {
       // --no-flag negation
-      const raw = token.slice(5)
-      const name = kebabToCamel.get(raw) ?? raw
-      if (!knownOptions.has(name)) throw new ParseError({ message: `Unknown flag: ${token}` })
-      rawOptions[name] = false
+      const name = normalizeOptionName(token.slice(5), optionNames)
+      if (!name) throw new ParseError({ message: `Unknown flag: ${token}` })
+      rawArgvOptions[name] = false
       i++
     } else if (token.startsWith('--')) {
       const eqIdx = token.indexOf('=')
       if (eqIdx !== -1) {
         // --flag=value
         const raw = token.slice(2, eqIdx)
-        const name = kebabToCamel.get(raw) ?? raw
-        if (!knownOptions.has(name)) throw new ParseError({ message: `Unknown flag: --${raw}` })
-        setOption(rawOptions, name, token.slice(eqIdx + 1), optionsSchema)
+        const name = normalizeOptionName(raw, optionNames)
+        if (!name) throw new ParseError({ message: `Unknown flag: --${raw}` })
+        setOption(rawArgvOptions, name, token.slice(eqIdx + 1), optionsSchema)
         i++
       } else {
         // --flag [value]
-        const raw = token.slice(2)
-        const name = kebabToCamel.get(raw) ?? raw
-        if (!knownOptions.has(name)) throw new ParseError({ message: `Unknown flag: ${token}` })
+        const name = normalizeOptionName(token.slice(2), optionNames)
+        if (!name) throw new ParseError({ message: `Unknown flag: ${token}` })
         if (isCountOption(name, optionsSchema)) {
-          rawOptions[name] = ((rawOptions[name] as number) ?? 0) + 1
+          rawArgvOptions[name] = ((rawArgvOptions[name] as number) ?? 0) + 1
           i++
         } else if (isBooleanOption(name, optionsSchema)) {
-          rawOptions[name] = true
+          rawArgvOptions[name] = true
           i++
         } else {
           const value = argv[i + 1]
           if (value === undefined)
             throw new ParseError({ message: `Missing value for flag: ${token}` })
-          setOption(rawOptions, name, value, optionsSchema)
+          setOption(rawArgvOptions, name, value, optionsSchema)
           i += 2
         }
       }
@@ -70,28 +59,28 @@ export function parse<
       const chars = token.slice(1)
       for (let j = 0; j < chars.length; j++) {
         const short = chars[j]!
-        const name = aliasToName.get(short)
+        const name = optionNames.aliasToName.get(short)
         if (!name) throw new ParseError({ message: `Unknown flag: -${short}` })
         const isLast = j === chars.length - 1
         if (!isLast) {
           if (isCountOption(name, optionsSchema)) {
-            rawOptions[name] = ((rawOptions[name] as number) ?? 0) + 1
+            rawArgvOptions[name] = ((rawArgvOptions[name] as number) ?? 0) + 1
           } else if (isBooleanOption(name, optionsSchema)) {
-            rawOptions[name] = true
+            rawArgvOptions[name] = true
           } else {
             throw new ParseError({
               message: `Non-boolean flag -${short} must be last in a stacked alias`,
             })
           }
         } else if (isCountOption(name, optionsSchema)) {
-          rawOptions[name] = ((rawOptions[name] as number) ?? 0) + 1
+          rawArgvOptions[name] = ((rawArgvOptions[name] as number) ?? 0) + 1
         } else if (isBooleanOption(name, optionsSchema)) {
-          rawOptions[name] = true
+          rawArgvOptions[name] = true
         } else {
           const value = argv[i + 1]
           if (value === undefined)
             throw new ParseError({ message: `Missing value for flag: -${short}` })
-          setOption(rawOptions, name, value, optionsSchema)
+          setOption(rawArgvOptions, name, value, optionsSchema)
           i++
         }
       }
@@ -117,15 +106,19 @@ export function parse<
   // Validate args through zod
   const args = argsSchema ? zodParse(argsSchema, rawArgs) : {}
 
+  const rawDefaults = normalizeOptionDefaults(defaults, optionsSchema, optionNames)
+
   // Coerce raw option values before zod validation
   if (optionsSchema) {
-    for (const [name, value] of Object.entries(rawOptions)) {
-      rawOptions[name] = coerce(value, name, optionsSchema)
+    for (const [name, value] of Object.entries(rawArgvOptions)) {
+      rawArgvOptions[name] = coerce(value, name, optionsSchema)
     }
   }
 
+  const mergedOptions = { ...rawDefaults, ...rawArgvOptions }
+
   // Validate options through zod
-  const parsedOptions = optionsSchema ? zodParse(optionsSchema, rawOptions) : {}
+  const parsedOptions = optionsSchema ? zodParse(optionsSchema, mergedOptions) : {}
 
   return { args, options: parsedOptions } as parse.ReturnType<args, options>
 }
@@ -138,6 +131,8 @@ export declare namespace parse {
   > = {
     /** Zod schema for positional arguments. Keys define order. */
     args?: args
+    /** Config-backed option defaults merged before argv parsing. */
+    defaults?: options extends z.ZodObject<any> ? Partial<z.input<options>> | undefined : undefined
     /** Zod schema for named options/flags. */
     options?: options
     /** Map of option names to single-char aliases. */
@@ -155,6 +150,62 @@ export declare namespace parse {
   }
 }
 
+type OptionNames = {
+  aliasToName: Map<string, string>
+  kebabToCamel: Map<string, string>
+  knownOptions: Set<string>
+}
+
+/** Builds lookup tables for option names and short aliases. */
+function createOptionNames(
+  schema: z.ZodObject<any> | undefined,
+  alias: Record<string, string> | undefined,
+): OptionNames {
+  const aliasToName = new Map<string, string>()
+  if (alias) for (const [name, short] of Object.entries(alias)) aliasToName.set(short, name)
+
+  const knownOptions = new Set(schema ? Object.keys(schema.shape) : [])
+  const kebabToCamel = new Map<string, string>()
+  for (const name of knownOptions) {
+    const kebab = toKebab(name)
+    if (kebab !== name) kebabToCamel.set(kebab, name)
+  }
+
+  return { aliasToName, kebabToCamel, knownOptions }
+}
+
+/** Normalizes a long option name, accepting kebab-case aliases for camelCase schema keys. */
+function normalizeOptionName(raw: string, options: OptionNames): string | undefined {
+  const name = options.kebabToCamel.get(raw) ?? raw
+  return options.knownOptions.has(name) ? name : undefined
+}
+
+/** Normalizes config-backed defaults and validates config structure/key names. */
+function normalizeOptionDefaults(
+  defaults: unknown,
+  schema: z.ZodObject<any> | undefined,
+  optionNames: OptionNames,
+): Record<string, unknown> {
+  if (defaults === undefined) return {}
+  if (!isRecord(defaults))
+    throw new ParseError({
+      message: 'Invalid config section: expected an object of option defaults',
+    })
+  if (!schema) {
+    const [first] = Object.keys(defaults)
+    if (first) throw new ParseError({ message: `Unknown config option: ${first}` })
+    return {}
+  }
+
+  const normalized: Record<string, unknown> = {}
+  for (const [rawName, value] of Object.entries(defaults)) {
+    const name = normalizeOptionName(rawName, optionNames)
+    if (!name) throw new ParseError({ message: `Unknown config option: ${rawName}` })
+    normalized[name] = value
+  }
+  return normalized
+}
+
 /** Unwraps ZodDefault/ZodOptional to get the inner type. */
 function unwrap(schema: z.ZodType): z.ZodType {
   let s = schema as any

package/src/Skill.ts

@@ -127,7 +127,11 @@ function renderGroup(
       ? `${descParts.join('. ')}. Run \`${title} --help\` for usage details.`
       : `Run \`${title} --help\` for usage details.`
 
-  const slug = title.replace(/\s+/g, '-')
+  const slug = title
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-|-$/g, '')
   const fm = ['---', `name: ${slug}`]
   fm.push(`description: ${description}`)
   fm.push(`requires_bin: ${cli}`)

package/src/SyncSkills.ts

@@ -150,7 +150,17 @@ function collectEntries(
 function resolvePackageRoot(): string {
   const bin = process.argv[1]
   if (!bin) return process.cwd()
-  let dir = path.dirname(fsSync.realpathSync(bin))
+  let dir = path.dirname(
+    (() => {
+      try {
+        // resolve symlinks for normal bin scripts
+        return fsSync.realpathSync(bin)
+      } catch {
+        // Bun compiled binaries use a virtual `/$bunfs/` path for argv[1]
+        return process.execPath
+      }
+    })(),
+  )
   const root = path.parse(dir).root
   while (dir !== root) {
     try {

package/src/bin.ts

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
+import fs from 'node:fs/promises'
 import path from 'node:path'
 import { z } from 'zod'
 
 import * as Cli from './Cli.js'
+import * as ConfigSchema from './internal/configSchema.js'
+import { importCli } from './internal/utils.js'
 import * as Typegen from './Typegen.js'
 
 const cli = Cli.create('incur', {
@@ -15,6 +18,10 @@ const cli = Cli.create('incur', {
 }).command('gen', {
   description: 'Generate type definitions for development.',
   options: z.object({
+    configSchema: z
+      .boolean()
+      .optional()
+      .describe('Generate config JSON Schema (auto-detected by default)'),
     dir: z.string().optional().describe('Project root directory'),
     entry: z.string().optional().describe('Entrypoint path (absolute)'),
     output: z.string().optional().describe('Output path (absolute)'),
@@ -23,8 +30,20 @@ const cli = Cli.create('incur', {
     const dir = c.options.dir ?? '.'
     const entry = c.options.entry ?? dir
     const output = c.options.output ?? path.join(dir, 'incur.generated.ts')
-    await Typegen.generate(entry, output)
-    return { dir, entry, output }
+
+    const cli = await importCli(entry)
+    await fs.writeFile(output, Typegen.fromCli(cli))
+
+    const result: Record<string, unknown> = { dir, entry, output }
+
+    const configSchema = c.options.configSchema ?? ConfigSchema.hasConfig(cli)
+    if (configSchema) {
+      const schemaOutput = path.join(path.dirname(output), 'config.schema.json')
+      await fs.writeFile(schemaOutput, JSON.stringify(ConfigSchema.fromCli(cli), null, 2) + '\n')
+      result.configSchema = schemaOutput
+    }
+
+    return result
   },
 })