incur 0.3.5 → 0.3.7

package/src/Cli.ts

@@ -1,15 +1,19 @@
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import * as path from 'node:path'
 import { estimateTokenCount, sliceByTokens } from 'tokenx'
 import type { z } from 'zod'
 
 import * as Completions from './Completions.js'
 import type { FieldError } from './Errors.js'
-import { IncurError, ValidationError } from './Errors.js'
+import { IncurError, ParseError, ValidationError } from './Errors.js'
 import * as Fetch from './Fetch.js'
 import * as Filter from './Filter.js'
 import * as Formatter from './Formatter.js'
 import * as Help from './Help.js'
 import { builtinCommands, type CommandMeta, type Shell, shells } from './internal/command.js'
 import * as Command from './internal/command.js'
+import { isRecord, suggest } from './internal/helpers.js'
 import { detectRunner } from './internal/pm.js'
 import type { OneOf } from './internal/types.js'
 import * as Mcp from './Mcp.js'
@@ -274,6 +278,7 @@ export function create(
       return serveImpl(name, commands, argv, {
         ...serveOptions,
         aliases: def.aliases,
+        config: def.config,
         description: def.description,
         envSchema: def.env,
         format: def.format,
@@ -295,6 +300,8 @@ export function create(
   }
 
   if (rootDef) toRootDefinition.set(cli as unknown as Root, rootDef)
+  if (def.options) toRootOptions.set(cli, def.options)
+  if (def.config !== undefined) toConfigEnabled.set(cli, true)
   if (def.outputPolicy) toOutputPolicy.set(cli, def.outputPolicy)
   toMiddlewares.set(cli, middlewares)
   toCommands.set(cli, commands)
@@ -318,6 +325,24 @@ export declare namespace create {
     aliases?: string[] | undefined
     /** Zod schema for positional arguments. */
     args?: args | undefined
+    /** Enable config-file defaults for command options. */
+    config?:
+      | {
+          /** Global flag name for specifying a config file path (e.g. `'config'` → `--config <path>`). Omit to auto-load only, with no CLI flag. */
+          flag?: string | undefined
+          /** Ordered list of file paths to search. First existing file wins. Supports `~` for home dir. Defaults to `['<cli>.json']` relative to cwd. */
+          files?: string[] | undefined
+          /** Custom config loader. Receives the resolved file path (or `undefined` if no file was found). Returns the parsed config tree, or `undefined` for no defaults. When omitted, the framework reads and parses JSON. */
+          loader?:
+            | ((
+                path: string | undefined,
+              ) =>
+                | Record<string, unknown>
+                | undefined
+                | Promise<Record<string, unknown> | undefined>)
+            | undefined
+        }
+      | undefined
     /** A short description of what the CLI does. */
     description?: string | undefined
     /** Zod schema for environment variables. Keys are the variable names (e.g. `NPM_TOKEN`). */
@@ -427,6 +452,24 @@ async function serveImpl(
 ) {
   const stdout = options.stdout ?? ((s: string) => process.stdout.write(s))
   const exit = options.exit ?? ((code: number) => process.exit(code))
+  const human = process.stdout.isTTY === true
+  const configEnabled = options.config !== undefined
+  const configFlag = options.config?.flag
+
+  function writeln(s: string) {
+    stdout(s.endsWith('\n') ? s : `${s}\n`)
+  }
+
+  let builtinFlags: ReturnType<typeof extractBuiltinFlags>
+  try {
+    builtinFlags = extractBuiltinFlags(argv, { configFlag })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    if (human) writeln(formatHumanError({ code: 'UNKNOWN', message }))
+    else writeln(Formatter.format({ code: 'UNKNOWN', message }, 'toon'))
+    exit(1)
+    return
+  }
 
   const {
     verbose,
@@ -442,8 +485,10 @@ async function serveImpl(
     help,
     version,
     schema,
+    configPath,
+    configDisabled,
     rest: filtered,
-  } = extractBuiltinFlags(argv)
+  } = builtinFlags
 
   // --mcp: start as MCP stdio server
   if (mcpFlag) {
@@ -495,14 +540,8 @@ async function serveImpl(
     return
   }
 
-  // Human mode: stdout is a TTY.
-  const human = process.stdout.isTTY === true
-
-  function writeln(s: string) {
-    stdout(s.endsWith('\n') ? s : `${s}\n`)
-  }
-
   // Skills staleness check (skip for built-in commands)
+  let skillsCta: FormattedCtaBlock | undefined
   if (!llms && !llmsFull && !schema && !help && !version) {
     const isSkillsAdd =
       filtered[0] === 'skills' || (filtered[0] === name && filtered[1] === 'skills')
@@ -515,9 +554,10 @@ async function serveImpl(
         if (Skill.hash(entries) !== stored) {
           const runner = detectRunner()
           const spec = SyncMcp.detectPackageSpecifier(name)
-          process.stderr.write(
-            `⚠ Skills are out of date. Run '${runner} ${spec} skills add' to update.\n\n`,
-          )
+          skillsCta = {
+            description: 'Skills are out of date:',
+            commands: [{ command: `${runner} ${spec} skills add`, description: 'sync outdated skills' }],
+          }
         }
       }
     }
@@ -608,7 +648,26 @@ async function serveImpl(
   const skillsIdx =
     filtered[0] === 'skills' ? 0 : filtered[0] === name && filtered[1] === 'skills' ? 1 : -1
   if (skillsIdx !== -1 && filtered[skillsIdx] === 'skills') {
-    if (filtered[skillsIdx + 1] !== 'add') {
+    const skillsSub = filtered[skillsIdx + 1]
+    if (skillsSub && skillsSub !== 'add') {
+      const suggestion = suggest(skillsSub, ['add'])
+      const didYouMean = suggestion ? ` Did you mean '${suggestion}'?` : ''
+      const message = `'${skillsSub}' is not a command for '${name} skills'.${didYouMean}`
+      const ctaCommands: FormattedCta[] = []
+      if (suggestion) {
+        const corrected = argv.map((t) => (t === skillsSub ? suggestion : t))
+        ctaCommands.push({ command: `${name} ${corrected.join(' ')}` })
+      }
+      ctaCommands.push({ command: `${name} skills --help`, description: 'see all available commands' })
+      const cta: FormattedCtaBlock = { description: 'Next steps:', commands: ctaCommands }
+      if (human) {
+        writeln(formatHumanError({ code: 'COMMAND_NOT_FOUND', message }))
+        writeln(formatHumanCta(cta))
+      } else writeln(Formatter.format({ code: 'COMMAND_NOT_FOUND', message, cta }, 'toon'))
+      exit(1)
+      return
+    }
+    if (!skillsSub) {
       const b = builtinCommands.find((c) => c.name === 'skills')!
       writeln(formatBuiltinHelp(name, b))
       return
@@ -680,7 +739,26 @@ async function serveImpl(
   // mcp add: register CLI as MCP server via `npx add-mcp`
   const mcpIdx = filtered[0] === 'mcp' ? 0 : filtered[0] === name && filtered[1] === 'mcp' ? 1 : -1
   if (mcpIdx !== -1 && filtered[mcpIdx] === 'mcp') {
-    if (filtered[mcpIdx + 1] !== 'add') {
+    const mcpSub = filtered[mcpIdx + 1]
+    if (mcpSub && mcpSub !== 'add') {
+      const suggestion = suggest(mcpSub, ['add'])
+      const didYouMean = suggestion ? ` Did you mean '${suggestion}'?` : ''
+      const message = `'${mcpSub}' is not a command for '${name} mcp'.${didYouMean}`
+      const ctaCommands: FormattedCta[] = []
+      if (suggestion) {
+        const corrected = argv.map((t) => (t === mcpSub ? suggestion : t))
+        ctaCommands.push({ command: `${name} ${corrected.join(' ')}` })
+      }
+      ctaCommands.push({ command: `${name} mcp --help`, description: 'see all available commands' })
+      const cta: FormattedCtaBlock = { description: 'Next steps:', commands: ctaCommands }
+      if (human) {
+        writeln(formatHumanError({ code: 'COMMAND_NOT_FOUND', message }))
+        writeln(formatHumanCta(cta))
+      } else writeln(Formatter.format({ code: 'COMMAND_NOT_FOUND', message, cta }, 'toon'))
+      exit(1)
+      return
+    }
+    if (!mcpSub) {
       const b = builtinCommands.find((c) => c.name === 'mcp')!
       writeln(formatBuiltinHelp(name, b))
       return
@@ -759,6 +837,7 @@ async function serveImpl(
         Help.formatCommand(name, {
           alias: cmd.alias as Record<string, string> | undefined,
           aliases: options.aliases,
+          configFlag,
           description: cmd.description ?? options.description,
           version: options.version,
           args: cmd.args,
@@ -780,6 +859,7 @@ async function serveImpl(
       writeln(
         Help.formatRoot(name, {
           aliases: options.aliases,
+          configFlag,
           description: options.description,
           version: options.version,
           commands: collectHelpCommands(commands),
@@ -828,6 +908,7 @@ async function serveImpl(
           Help.formatCommand(name, {
             alias: cmd.alias as Record<string, string> | undefined,
             aliases: options.aliases,
+            configFlag,
             description: cmd.description ?? options.description,
             version: options.version,
             args: cmd.args,
@@ -845,6 +926,7 @@ async function serveImpl(
         writeln(
           Help.formatRoot(helpName, {
             aliases: isRoot ? options.aliases : undefined,
+            configFlag,
             description: helpDesc,
             version: isRoot ? options.version : undefined,
             commands: collectHelpCommands(helpCmds),
@@ -864,6 +946,7 @@ async function serveImpl(
         Help.formatCommand(commandName, {
           alias: cmd.alias as Record<string, string> | undefined,
           aliases: isRootCmd ? options.aliases : undefined,
+          configFlag,
           description: cmd.description,
           version: isRootCmd ? options.version : undefined,
           args: cmd.args,
@@ -886,6 +969,7 @@ async function serveImpl(
     if ('help' in resolved) {
       writeln(
         Help.formatRoot(`${name} ${resolved.path}`, {
+          configFlag,
           description: resolved.description,
           commands: collectHelpCommands(resolved.commands),
         }),
@@ -894,7 +978,9 @@ async function serveImpl(
     }
     if ('error' in resolved) {
       const parent = resolved.path ? `${name} ${resolved.path}` : name
-      writeln(`Error: '${resolved.error}' is not a command for '${parent}'.`)
+      const suggestion = suggest(resolved.error, resolved.commands.keys())
+      const didYouMean = suggestion ? ` Did you mean '${suggestion}'?` : ''
+      writeln(`Error: '${resolved.error}' is not a command for '${parent}'.${didYouMean}`)
       exit(1)
       return
     }
@@ -917,6 +1003,7 @@ async function serveImpl(
   if ('help' in resolved) {
     writeln(
       Help.formatRoot(`${name} ${resolved.path}`, {
+        configFlag,
         description: resolved.description,
         commands: collectHelpCommands(resolved.commands),
       }),
@@ -977,6 +1064,21 @@ async function serveImpl(
   function write(output: Output) {
     if (filterPaths && output.ok && output.data != null)
       output = { ...output, data: Filter.apply(output.data, filterPaths) }
+    if (skillsCta) {
+      const existing = output.meta.cta
+      output = {
+        ...output,
+        meta: {
+          ...output.meta,
+          cta: existing
+            ? {
+                description: existing.description,
+                commands: [...existing.commands, ...skillsCta.commands],
+              }
+            : skillsCta,
+        },
+      }
+    }
     if (tokenCount) {
       const base = output.ok ? output.data : output.error
       const formatted = base != null ? Formatter.format(base, format) : ''
@@ -1027,14 +1129,24 @@ async function serveImpl(
   if ('error' in effective) {
     const helpCmd = effective.path ? `${name} ${effective.path} --help` : `${name} --help`
     const parent = effective.path ? `${name} ${effective.path}` : name
-    const message = `'${effective.error}' is not a command for '${parent}'.`
-    const cta: FormattedCtaBlock = {
-      description: 'See available commands:',
-      commands: [{ command: helpCmd }],
+    const candidates = 'commands' in effective ? [...effective.commands.keys()] : []
+    if (!effective.path) for (const b of builtinCommands) candidates.push(b.name)
+    const suggestion = suggest(effective.error, candidates)
+    const didYouMean = suggestion ? ` Did you mean '${suggestion}'?` : ''
+    const message = `'${effective.error}' is not a command for '${parent}'.${didYouMean}`
+    const ctaCommands: FormattedCta[] = []
+    if (suggestion) {
+      const corrected = argv.map((t) => (t === effective.error ? suggestion : t))
+      ctaCommands.push({ command: `${name} ${corrected.join(' ')}` })
     }
+    ctaCommands.push({ command: helpCmd, description: 'see all available commands' })
+    const cta: FormattedCtaBlock = { description: 'Next steps:', commands: ctaCommands }
     if (human && !verbose) {
       writeln(formatHumanError({ code: 'COMMAND_NOT_FOUND', message }))
-      writeln(formatHumanCta(cta))
+      const mergedCta = skillsCta
+        ? { ...cta, commands: [...cta.commands, ...skillsCta.commands] }
+        : cta
+      writeln(formatHumanCta(mergedCta))
       exit(1)
       return
     }
@@ -1205,9 +1317,33 @@ async function serveImpl(
       command.alias as Record<string, string> | undefined,
     )
 
+  let defaults: Record<string, unknown> | undefined
+  if (configEnabled) {
+    try {
+      defaults = await loadCommandOptionDefaults(name, path, {
+        configDisabled,
+        configPath,
+        files: options.config?.files,
+        loader: options.config?.loader,
+      })
+    } catch (error) {
+      write({
+        ok: false,
+        error: {
+          code: error instanceof IncurError ? error.code : 'UNKNOWN',
+          message: error instanceof Error ? error.message : String(error),
+        },
+        meta: { command: path, duration: `${Math.round(performance.now() - start)}ms` },
+      })
+      exit(error instanceof IncurError ? (error.exitCode ?? 1) : 1)
+      return
+    }
+  }
+
   const result = await Command.execute(command, {
     agent: !human,
     argv: rest,
+    defaults,
     env: options.envSchema,
     envSource: options.env,
     format,
@@ -1266,6 +1402,7 @@ async function serveImpl(
             fieldErrors: result.error.fieldErrors,
           }),
           options.env,
+          configFlag,
         ),
       )
       exit(1)
@@ -1474,18 +1611,22 @@ async function fetchImpl(
 
   const resolved = resolveCommand(commands, segments)
 
-  if ('error' in resolved)
+  if ('error' in resolved) {
+    const parent = resolved.path ? `${name} ${resolved.path}` : name
+    const suggestion = suggest(resolved.error, resolved.commands.keys())
+    const didYouMean = suggestion ? ` Did you mean '${suggestion}'?` : ''
     return jsonResponse(
       {
         ok: false,
         error: {
           code: 'COMMAND_NOT_FOUND',
-          message: `'${resolved.error}' is not a command for '${resolved.path ? `${name} ${resolved.path}` : name}'.`,
+          message: `'${resolved.error}' is not a command for '${parent}'.${didYouMean}`,
         },
         meta: { command: resolved.error, duration: `${Math.round(performance.now() - start)}ms` },
       },
       404,
     )
+  }
 
   if ('help' in resolved)
     return jsonResponse(
@@ -1636,6 +1777,7 @@ function formatHumanValidationError(
   command: CommandDefinition<any, any, any>,
   error: ValidationError,
   envSource?: Record<string, string | undefined>,
+  configFlag?: string,
 ): string {
   const lines: string[] = []
   for (const fe of error.fieldErrors) lines.push(`Error: missing required argument <${fe.path}>`)
@@ -1644,6 +1786,7 @@ function formatHumanValidationError(
   lines.push(
     Help.formatCommand(path === cli ? cli : `${cli} ${path}`, {
       alias: command.alias as Record<string, string> | undefined,
+      configFlag,
       description: command.description,
       args: command.args,
       env: command.env,
@@ -1682,10 +1825,10 @@ function resolveCommand(
       description?: string | undefined
       commands: Map<string, CommandEntry>
     }
-  | { error: string; path: string } {
+  | { error: string; path: string; commands: Map<string, CommandEntry>; rest: string[] } {
   const [first, ...rest] = tokens
 
-  if (!first || !commands.has(first)) return { error: first ?? '(none)', path: '' }
+  if (!first || !commands.has(first)) return { error: first ?? '(none)', path: '', commands, rest }
 
   let entry = commands.get(first)!
   const path = [first]
@@ -1719,7 +1862,7 @@ function resolveCommand(
 
     const child = entry.commands.get(next)
     if (!child) {
-      return { error: next, path: path.join(' ') }
+      return { error: next, path: path.join(' '), commands: entry.commands, rest: remaining.slice(1) }
     }
 
     path.push(next)
@@ -1753,6 +1896,20 @@ declare namespace serveImpl {
   type Options = serve.Options & {
     /** Alternative binary names for this CLI. */
     aliases?: string[] | undefined
+    config?:
+      | {
+          flag?: string | undefined
+          files?: string[] | undefined
+          loader?:
+            | ((
+                path: string | undefined,
+              ) =>
+                | Record<string, unknown>
+                | undefined
+                | Promise<Record<string, unknown> | undefined>)
+            | undefined
+        }
+      | undefined
     description?: string | undefined
     /** CLI-level env schema. Parsed before middleware runs. */
     envSchema?: z.ZodObject<any> | undefined
@@ -1787,7 +1944,7 @@ declare namespace serveImpl {
 }
 
 /** @internal Extracts built-in flags (--verbose, --format, --json, --llms, --help, --version) from argv. */
-function extractBuiltinFlags(argv: string[]) {
+function extractBuiltinFlags(argv: string[], options: extractBuiltinFlags.Options = {}) {
   let verbose = false
   let llms = false
   let llmsFull = false
@@ -1797,12 +1954,18 @@ function extractBuiltinFlags(argv: string[]) {
   let schema = false
   let format: Formatter.Format = 'toon'
   let formatExplicit = false
+  let configPath: string | undefined
+  let configDisabled = false
   let filterOutput: string | undefined
   let tokenLimit: number | undefined
   let tokenOffset: number | undefined
   let tokenCount = false
   const rest: string[] = []
 
+  const cfgFlag = options.configFlag ? `--${options.configFlag}` : undefined
+  const cfgFlagEq = options.configFlag ? `--${options.configFlag}=` : undefined
+  const noCfgFlag = options.configFlag ? `--no-${options.configFlag}` : undefined
+
   for (let i = 0; i < argv.length; i++) {
     const token = argv[i]!
     if (token === '--verbose') verbose = true
@@ -1819,6 +1982,22 @@ function extractBuiltinFlags(argv: string[]) {
       format = argv[i + 1] as Formatter.Format
       formatExplicit = true
       i++
+    } else if (cfgFlag && token === cfgFlag) {
+      const value = argv[i + 1]
+      if (value === undefined)
+        throw new ParseError({ message: `Missing value for flag: ${cfgFlag}` })
+      configPath = value
+      configDisabled = false
+      i++
+    } else if (cfgFlagEq && token.startsWith(cfgFlagEq)) {
+      const value = token.slice(cfgFlagEq.length)
+      if (value.length === 0)
+        throw new ParseError({ message: `Missing value for flag: ${cfgFlag}` })
+      configPath = value
+      configDisabled = false
+    } else if (noCfgFlag && token === noCfgFlag) {
+      configPath = undefined
+      configDisabled = true
     } else if (token === '--filter-output' && argv[i + 1]) {
       filterOutput = argv[i + 1]!
       i++
@@ -1836,6 +2015,8 @@ function extractBuiltinFlags(argv: string[]) {
     verbose,
     format,
     formatExplicit,
+    configPath,
+    configDisabled,
     filterOutput,
     tokenLimit,
     tokenOffset,
@@ -1850,6 +2031,145 @@ function extractBuiltinFlags(argv: string[]) {
   }
 }
 
+declare namespace extractBuiltinFlags {
+  type Options = {
+    configFlag?: string | undefined
+  }
+}
+
+/** @internal Loads config-backed option defaults for the active command. */
+async function loadCommandOptionDefaults(
+  cli: string,
+  path: string,
+  options: loadCommandOptionDefaults.Options = {},
+): Promise<Record<string, unknown> | undefined> {
+  if (options.configDisabled) return undefined
+
+  const { loader } = options
+
+  // Resolve the target file path
+  let targetPath: string | undefined
+  if (options.configPath) {
+    targetPath = resolveConfigPath(options.configPath)
+  } else {
+    const searchPaths = options.files ?? [`${cli}.json`]
+    targetPath = await findFirstExisting(searchPaths)
+  }
+
+  // Load and parse the config
+  let parsed: Record<string, unknown>
+  if (loader) {
+    const result = await loader(targetPath)
+    if (result === undefined) return undefined
+    if (!isRecord(result))
+      throw new ParseError({ message: 'Config loader must return a plain object or undefined' })
+    parsed = result
+  } else {
+    if (!targetPath) return undefined
+    const result = await readJsonConfig(targetPath, !!options.configPath)
+    if (!result) return undefined
+    parsed = result
+  }
+
+  // Extract the command section from the config tree
+  return extractCommandSection(parsed, cli, path)
+}
+
+declare namespace loadCommandOptionDefaults {
+  type Options = {
+    configDisabled?: boolean | undefined
+    configPath?: string | undefined
+    files?: string[] | undefined
+    loader?:
+      | ((
+          path: string | undefined,
+        ) => Record<string, unknown> | undefined | Promise<Record<string, unknown> | undefined>)
+      | undefined
+  }
+}
+
+/** @internal Resolves a config file path, expanding `~` to home dir. */
+function resolveConfigPath(filePath: string): string {
+  if (filePath.startsWith('~/') || filePath === '~') {
+    return path.join(os.homedir(), filePath.slice(1))
+  }
+  return path.resolve(process.cwd(), filePath)
+}
+
+/** @internal Returns the first readable file from a list of paths, or `undefined`. */
+async function findFirstExisting(paths: string[]): Promise<string | undefined> {
+  for (const p of paths) {
+    const resolved = resolveConfigPath(p)
+    try {
+      await fs.access(resolved, fs.constants.R_OK)
+      return resolved
+    } catch {}
+  }
+  return undefined
+}
+
+/** @internal Reads and parses a JSON config file. */
+async function readJsonConfig(
+  targetPath: string,
+  explicit: boolean,
+): Promise<Record<string, unknown> | undefined> {
+  let raw: string
+  try {
+    raw = await fs.readFile(targetPath, 'utf8')
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      if (explicit) throw new ParseError({ message: `Config file not found: ${targetPath}` })
+      return undefined
+    }
+    throw error
+  }
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch (error) {
+    throw new ParseError({
+      message: `Invalid JSON config file: ${targetPath}`,
+      cause: error instanceof Error ? error : undefined,
+    })
+  }
+
+  if (!isRecord(parsed))
+    throw new ParseError({
+      message: `Invalid config file: expected a top-level object in ${targetPath}`,
+    })
+  return parsed
+}
+
+/** @internal Walks the nested config tree to extract option defaults for a command path. */
+function extractCommandSection(
+  parsed: Record<string, unknown>,
+  cli: string,
+  path: string,
+): Record<string, unknown> | undefined {
+  const segments = path === cli ? [] : path.split(' ')
+  let node: unknown = parsed
+  for (const seg of segments) {
+    if (!isRecord(node)) return undefined
+    const commands = node.commands
+    if (!isRecord(commands)) return undefined
+    node = commands[seg]
+    if (node === undefined) return undefined
+  }
+  if (!isRecord(node))
+    throw new ParseError({
+      message: `Invalid config section for '${path}': expected an object`,
+    })
+
+  const options = node.options
+  if (options === undefined) return undefined
+  if (!isRecord(options))
+    throw new ParseError({
+      message: `Invalid config 'options' for '${path}': expected an object`,
+    })
+  return Object.keys(options).length > 0 ? options : undefined
+}
+
 /** @internal Collects immediate child commands/groups for help output. */
 function collectHelpCommands(
   commands: Map<string, CommandEntry>,
@@ -1953,7 +2273,13 @@ export const toCommands = new WeakMap<Cli, Map<string, CommandEntry>>()
 const toMiddlewares = new WeakMap<Cli, MiddlewareHandler[]>()
 
 /** @internal Maps root CLI instances to their command definitions. */
-const toRootDefinition = new WeakMap<Root, CommandDefinition<any, any, any>>()
+export const toRootDefinition = new WeakMap<Root, CommandDefinition<any, any, any>>()
+
+/** @internal Maps CLI instances to their root options schema. */
+export const toRootOptions = new WeakMap<Cli, z.ZodObject<any>>()
+
+/** @internal Maps CLI instances to whether config file loading is enabled. */
+export const toConfigEnabled = new WeakMap<Cli, boolean>()
 
 /** @internal Maps CLI instances to their output policy. */
 const toOutputPolicy = new WeakMap<Cli, OutputPolicy>()

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,