@outfitter/cli 0.5.2 → 1.0.0

package/dist/command.js

@@ -1,10 +1,87 @@
 // @bun
 import {
   createCLI
-} from "./shared/@outfitter/cli-zahqsaby.js";
+} from "./shared/@outfitter/cli-d40m2x1d.js";
+import {
+  resolveOutputMode
+} from "./shared/@outfitter/cli-vvvhjwks.js";
+import {
+  isSchemaPreset
+} from "./shared/@outfitter/cli-8999qjdd.js";
+import"./shared/@outfitter/cli-89335n9a.js";
+import"./shared/@outfitter/cli-htzez8v2.js";
+import"./shared/@outfitter/cli-hvg2m5gf.js";
+import"./shared/@outfitter/cli-2dfxs239.js";
+import {
+  exitWithError
+} from "./shared/@outfitter/cli-4h85mpth.js";
+import"./shared/@outfitter/cli-dg0cz7rw.js";
+import {
+  createCommanderOption,
+  deriveFlags,
+  validateInput
+} from "./shared/@outfitter/cli-3jta1h1h.js";
 
 // packages/cli/src/command.ts
 import { Command } from "commander";
+import { z } from "zod";
+function buildMergedSchema(inputSchema, schemaPresets) {
+  if (!inputSchema && schemaPresets.length === 0)
+    return;
+  if (schemaPresets.length === 0)
+    return inputSchema;
+  if (!inputSchema && schemaPresets.length === 1) {
+    return schemaPresets[0].schema;
+  }
+  const inputKeys = new Set(Object.keys(inputSchema?.shape ?? {}));
+  const omitOverriddenPresetFields = (schema) => {
+    if (inputKeys.size === 0) {
+      return schema;
+    }
+    const filteredEntries = Object.entries(schema.shape).filter(([key]) => !inputKeys.has(key));
+    if (filteredEntries.length === 0) {
+      return;
+    }
+    const filteredShape = Object.fromEntries(filteredEntries);
+    return z.object(filteredShape);
+  };
+  const mergedShape = {};
+  const allSchemas = [];
+  for (const preset of schemaPresets) {
+    const filteredPresetSchema = omitOverriddenPresetFields(preset.schema);
+    if (!filteredPresetSchema) {
+      continue;
+    }
+    Object.assign(mergedShape, filteredPresetSchema.shape);
+    allSchemas.push(filteredPresetSchema);
+  }
+  if (inputSchema) {
+    Object.assign(mergedShape, inputSchema.shape);
+    allSchemas.push(inputSchema);
+  }
+  return {
+    shape: mergedShape,
+    safeParse(data) {
+      let merged = {};
+      for (const schema of allSchemas) {
+        const schemaData = {};
+        if (data && typeof data === "object") {
+          for (const key of Object.keys(schema.shape)) {
+            if (key in data) {
+              schemaData[key] = data[key];
+            }
+          }
+        }
+        const result = schema.safeParse(schemaData);
+        if (!result.success) {
+          return result;
+        }
+        merged = { ...merged, ...result.data };
+      }
+      return { success: true, data: merged };
+    }
+  };
+}
 function parseCommandSignature(signature) {
   const trimmed = signature.trim();
   const firstWhitespace = trimmed.search(/\s/);
@@ -23,51 +100,202 @@ function createCLI2(config) {
 }
 
 class CommandBuilderImpl {
-  command;
+  cmd;
+  inputSchema;
+  ctxFactory;
+  successHintFn;
+  errorHintsFn;
+  explicitLongFlags = new Set;
+  schemaPresets = [];
+  schemaFlagsApplied = false;
+  _destructive = false;
+  _readOnly = false;
+  _idempotent = false;
+  _relatedTo = [];
   constructor(signature) {
     const { name, argumentsSpec } = parseCommandSignature(signature);
-    this.command = new Command(name);
+    this.cmd = new Command(name);
     if (argumentsSpec) {
-      this.command.arguments(argumentsSpec);
+      this.cmd.arguments(argumentsSpec);
     }
   }
   description(text) {
-    this.command.description(text);
+    this.cmd.description(text);
     return this;
   }
   option(flags, description, defaultValue) {
-    this.command.option(flags, description, defaultValue);
+    const longMatch = flags.match(/--([a-z][a-z0-9-]*)/i);
+    if (longMatch) {
+      this.explicitLongFlags.add(`--${longMatch[1]}`);
+    }
+    this.cmd.option(flags, description, defaultValue);
     return this;
   }
   requiredOption(flags, description, defaultValue) {
-    this.command.requiredOption(flags, description, defaultValue);
+    const longMatch = flags.match(/--([a-z][a-z0-9-]*)/i);
+    if (longMatch) {
+      this.explicitLongFlags.add(`--${longMatch[1]}`);
+    }
+    this.cmd.requiredOption(flags, description, defaultValue);
     return this;
   }
   alias(alias) {
-    this.command.alias(alias);
+    this.cmd.alias(alias);
+    return this;
+  }
+  input(schema) {
+    this.inputSchema = schema;
+    return this;
+  }
+  context(factory) {
+    this.ctxFactory = factory;
+    return this;
+  }
+  hints(fn) {
+    this.successHintFn = fn;
+    return this;
+  }
+  onError(fn) {
+    this.errorHintsFn = fn;
+    return this;
+  }
+  destructive(isDest) {
+    this._destructive = isDest;
+    return this;
+  }
+  readOnly(isReadOnly) {
+    this._readOnly = isReadOnly;
+    return this;
+  }
+  idempotent(isIdempotent) {
+    this._idempotent = isIdempotent;
+    return this;
+  }
+  relatedTo(target, options) {
+    this._relatedTo.push({
+      target,
+      ...options?.description ? { description: options.description } : {}
+    });
     return this;
   }
   preset(preset) {
+    if (isSchemaPreset(preset)) {
+      this.schemaPresets.push(preset);
+      return this;
+    }
     for (const opt of preset.options) {
+      const longMatch = opt.flags.match(/--([a-z][a-z0-9-]*)/i);
+      if (longMatch) {
+        this.explicitLongFlags.add(`--${longMatch[1]}`);
+      }
       if (opt.required) {
-        this.command.requiredOption(opt.flags, opt.description, opt.defaultValue);
+        this.cmd.requiredOption(opt.flags, opt.description, opt.defaultValue);
       } else {
-        this.command.option(opt.flags, opt.description, opt.defaultValue);
+        this.cmd.option(opt.flags, opt.description, opt.defaultValue);
       }
     }
     return this;
   }
   action(handler) {
-    this.command.action(async (...args) => {
+    const schema = this.inputSchema;
+    const contextFactory = this.ctxFactory;
+    const presets = [...this.schemaPresets];
+    this.applySchemaFlags();
+    const mergedSchema = buildMergedSchema(schema, presets);
+    this.cmd.action(async (...args) => {
       const command = args.at(-1);
       const flags = command.optsWithGlobals?.() ?? command.opts();
       const positional = command.args;
-      await handler({ args: positional, flags, command });
+      let input;
+      let ctx;
+      try {
+        input = mergedSchema ? validateInput(flags, mergedSchema) : undefined;
+        if (input !== undefined && presets.length > 0) {
+          for (const preset of presets) {
+            const resolved = preset.resolve(flags);
+            Object.assign(input, resolved);
+          }
+        }
+        if (contextFactory) {
+          const factoryArg = input !== undefined ? input : flags;
+          ctx = await contextFactory(factoryArg);
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        const { mode } = resolveOutputMode(flags);
+        exitWithError(error, mode);
+        return;
+      }
+      await handler({
+        args: positional,
+        flags,
+        command,
+        input,
+        ctx
+      });
     });
     return this;
   }
   build() {
-    return this.command;
+    this.applySchemaFlags();
+    this.applyDestructiveFlag();
+    if (this.successHintFn) {
+      this.cmd.__successHintFn = this.successHintFn;
+    }
+    if (this.errorHintsFn) {
+      this.cmd.__errorHintFn = this.errorHintsFn;
+    }
+    const metadata = {};
+    if (this._readOnly) {
+      metadata.readOnly = true;
+    }
+    if (this._idempotent) {
+      metadata.idempotent = true;
+    }
+    if (metadata.readOnly !== undefined || metadata.idempotent !== undefined) {
+      this.cmd.__metadata = metadata;
+    }
+    if (this._relatedTo.length > 0) {
+      this.cmd.__relatedTo = [...this._relatedTo];
+    }
+    return this.cmd;
+  }
+  applySchemaFlags() {
+    if (this.schemaFlagsApplied)
+      return;
+    if (!this.inputSchema && this.schemaPresets.length === 0)
+      return;
+    this.schemaFlagsApplied = true;
+    const existingLongs = new Set(this.explicitLongFlags);
+    for (const opt of this.cmd.options) {
+      if (opt.long) {
+        existingLongs.add(opt.long);
+      }
+    }
+    if (this.inputSchema) {
+      const derived = deriveFlags(this.inputSchema, existingLongs);
+      for (const flag of derived) {
+        const option = createCommanderOption(flag, this.inputSchema);
+        this.cmd.addOption(option);
+        existingLongs.add(flag.longFlag);
+      }
+    }
+    for (const schemaPreset of this.schemaPresets) {
+      const derived = deriveFlags(schemaPreset.schema, existingLongs);
+      for (const flag of derived) {
+        const option = createCommanderOption(flag, schemaPreset.schema);
+        this.cmd.addOption(option);
+        existingLongs.add(flag.longFlag);
+      }
+    }
+  }
+  applyDestructiveFlag() {
+    if (!this._destructive)
+      return;
+    const hasDryRun = this.cmd.options.some((o) => o.long === "--dry-run");
+    if (hasDryRun)
+      return;
+    this.cmd.option("--dry-run", "Preview changes without applying (destructive command safety)", false);
   }
 }
 function command(name) {

package/dist/envelope.d.ts

@@ -0,0 +1,5 @@
+import { runHandler } from "./shared/@outfitter/cli-c09332vm.js";
+import { createErrorEnvelope, createSuccessEnvelope } from "./shared/@outfitter/cli-nkt399zf.js";
+import { CommandEnvelope, ErrorEnvelope, RunHandlerOptions, SuccessEnvelope } from "./shared/@outfitter/cli-30mt7c5w.js";
+import "./shared/@outfitter/cli-x6qr7bnd.js";
+export { runHandler, createSuccessEnvelope, createErrorEnvelope, SuccessEnvelope, RunHandlerOptions, ErrorEnvelope, CommandEnvelope };

package/dist/envelope.js

@@ -0,0 +1,160 @@
+// @bun
+import {
+  buildDryRunHint,
+  createErrorEnvelope,
+  createSuccessEnvelope,
+  extractCategory,
+  extractMessage,
+  extractRetryAfterSeconds,
+  formatEnvelopeHuman,
+  getExitCode,
+  safeCallHintFn
+} from "./shared/@outfitter/cli-ry7btmy4.js";
+import {
+  createNdjsonProgress,
+  writeNdjsonLine,
+  writeStreamEnvelope
+} from "./shared/@outfitter/cli-g43887b7.js";
+import {
+  output
+} from "./shared/@outfitter/cli-4h85mpth.js";
+import {
+  detectMode
+} from "./shared/@outfitter/cli-dg0cz7rw.js";
+
+// packages/cli/src/envelope.ts
+import { safeStringify } from "@outfitter/contracts";
+async function runHandler(options) {
+  const {
+    command: commandName,
+    handler,
+    input,
+    format,
+    contextFactory,
+    hints: hintsFn,
+    onError: onErrorFn,
+    stream: isStreaming = false,
+    dryRun: isDryRun = false
+  } = options;
+  const inputValue = input;
+  const resolvedFormat = format ?? detectMode();
+  const isJsonMode = resolvedFormat === "json" || resolvedFormat === "jsonl";
+  let progressCallback;
+  if (isStreaming) {
+    const startEvent = {
+      type: "start",
+      command: commandName,
+      ts: new Date().toISOString()
+    };
+    writeNdjsonLine(startEvent);
+    const writeProgress = createNdjsonProgress(commandName);
+    progressCallback = (event) => {
+      if (event.type === "start") {
+        return;
+      }
+      writeProgress(event);
+    };
+  }
+  let context;
+  if (contextFactory) {
+    try {
+      const rawContext = await contextFactory(inputValue);
+      if (isStreaming && rawContext && typeof rawContext === "object") {
+        context = Object.assign(Object.create(Object.getPrototypeOf(rawContext)), rawContext, { progress: progressCallback });
+      } else {
+        context = rawContext;
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const category = extractCategory(error);
+      const message = extractMessage(error);
+      const retryAfter = extractRetryAfterSeconds(error);
+      const errorHints = onErrorFn ? safeCallHintFn(() => onErrorFn(error, inputValue)) : undefined;
+      const envelope = createErrorEnvelope(commandName, category, message, errorHints, retryAfter);
+      if (isStreaming) {
+        writeStreamEnvelope(envelope);
+        const exitCode = getExitCode(category);
+        process.exit(exitCode);
+      }
+      outputErrorEnvelope(envelope, isJsonMode);
+      return;
+    }
+  } else if (isStreaming) {
+    context = { progress: progressCallback };
+  } else {
+    context = undefined;
+  }
+  let result;
+  try {
+    result = await handler(inputValue, context);
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    const category = extractCategory(error);
+    const message = extractMessage(error);
+    const retryAfter = extractRetryAfterSeconds(error);
+    const errorHints = onErrorFn ? safeCallHintFn(() => onErrorFn(error, inputValue)) : undefined;
+    const envelope = createErrorEnvelope(commandName, category, message, errorHints, retryAfter);
+    if (isStreaming) {
+      writeStreamEnvelope(envelope);
+      const exitCode = getExitCode(category);
+      process.exit(exitCode);
+    }
+    outputErrorEnvelope(envelope, isJsonMode);
+    return;
+  }
+  if (result.isOk()) {
+    let successHints = hintsFn ? safeCallHintFn(() => hintsFn(result.value, inputValue)) : undefined;
+    if (isDryRun) {
+      const dryRunHint = buildDryRunHint(options.argv);
+      if (dryRunHint) {
+        successHints = successHints ? [...successHints, dryRunHint] : [dryRunHint];
+      }
+    }
+    const envelope = createSuccessEnvelope(commandName, result.value, successHints);
+    if (isStreaming) {
+      writeStreamEnvelope(envelope);
+      return;
+    }
+    if (isJsonMode) {
+      await output(envelope, resolvedFormat);
+    } else {
+      const formatted = formatEnvelopeHuman(envelope);
+      if (formatted.stdout) {
+        process.stdout.write(`${formatted.stdout}
+`);
+      }
+    }
+  } else {
+    const error = result.error;
+    const category = extractCategory(error);
+    const message = extractMessage(error);
+    const retryAfter = extractRetryAfterSeconds(error);
+    const errorHints = onErrorFn ? safeCallHintFn(() => onErrorFn(error, inputValue)) : undefined;
+    const envelope = createErrorEnvelope(commandName, category, message, errorHints, retryAfter);
+    if (isStreaming) {
+      writeStreamEnvelope(envelope);
+      const exitCode = getExitCode(category);
+      process.exit(exitCode);
+    }
+    outputErrorEnvelope(envelope, isJsonMode);
+  }
+}
+function outputErrorEnvelope(envelope, isJsonMode) {
+  const exitCode = getExitCode(envelope.error.category);
+  if (isJsonMode) {
+    process.stderr.write(`${safeStringify(envelope)}
+`);
+  } else {
+    const formatted = formatEnvelopeHuman(envelope);
+    if (formatted.stderr) {
+      process.stderr.write(`${formatted.stderr}
+`);
+    }
+  }
+  process.exit(exitCode);
+}
+export {
+  runHandler,
+  createSuccessEnvelope,
+  createErrorEnvelope
+};

package/dist/flags.d.ts

@@ -1,189 +1,5 @@
-import { BooleanFlagPresetConfig, ColorFlags, ColorMode, ComposedPreset, EnumFlagPresetConfig, ExecutionFlags, ExecutionPresetConfig, FlagPreset, FlagPresetConfig, InteractionFlags, NumberFlagPresetConfig, PaginationFlags, PaginationPresetConfig, ProjectionFlags, StrictFlags, StringListFlagPresetConfig, TimeWindowFlags, TimeWindowPresetConfig } from "./shared/@outfitter/cli-98aa9104.js";
-/**
-* Create a typed flag preset.
-*
-* @param config - Preset configuration with id, options, and resolver
-* @returns A flag preset that can be applied to commands or composed
-*
-* @example
-* ```typescript
-* const myPreset = createPreset({
-*   id: "output-format",
-*   options: [{ flags: "--format <type>", description: "Output format" }],
-*   resolve: (flags) => ({
-*     format: String(flags["format"] ?? "text"),
-*   }),
-* });
-* ```
-*/
-declare function createPreset<TResolved extends Record<string, unknown>>(config: FlagPresetConfig<TResolved>): FlagPreset<TResolved>;
-type ResolvedType<T> = T extends FlagPreset<infer R> ? R : never;
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-/**
-* Resolves the merged type from a tuple of presets.
-* Falls back to Record<string, unknown> when the tuple is empty
-* (since UnionToIntersection<never> produces unknown).
-*/
-type MergedPresetResult<TPresets extends readonly FlagPreset<Record<string, unknown>>[]> = UnionToIntersection<ResolvedType<TPresets[number]>> extends Record<string, unknown> ? UnionToIntersection<ResolvedType<TPresets[number]>> : Record<string, unknown>;
-/**
-* Compose multiple presets into one, deduplicating by id (first wins).
-*
-* @param presets - Presets to compose together
-* @returns A single preset merging all options and resolvers
-*
-* @example
-* ```typescript
-* const composed = composePresets(
-*   verbosePreset(),
-*   cwdPreset(),
-*   forcePreset(),
-* );
-* // composed.resolve({ verbose: true, cwd: "/tmp", force: false })
-* // => { verbose: true, cwd: "/tmp", force: false }
-* ```
-*/
-declare function composePresets<TPresets extends readonly FlagPreset<Record<string, unknown>>[]>(...presets: TPresets): ComposedPreset<MergedPresetResult<TPresets>>;
-/**
-* Generic boolean custom-flag builder.
-*
-* Supports normal sources and negated sources so `--no-foo` patterns can
-* resolve consistently across Commander flag-shape differences.
-*/
-declare function booleanFlagPreset<TKey extends string>(config: BooleanFlagPresetConfig<TKey>): FlagPreset<{ [K in TKey] : boolean }>;
-/**
-* Generic enum custom-flag builder.
-*/
-declare function enumFlagPreset<
-	TKey extends string,
-	TValue extends string
->(config: EnumFlagPresetConfig<TKey, TValue>): FlagPreset<{ [K in TKey] : TValue }>;
-/**
-* Generic number custom-flag builder.
-*/
-declare function numberFlagPreset<TKey extends string>(config: NumberFlagPresetConfig<TKey>): FlagPreset<{ [K in TKey] : number }>;
-/**
-* Generic string-list custom-flag builder.
-*/
-declare function stringListFlagPreset<TKey extends string>(config: StringListFlagPresetConfig<TKey>): FlagPreset<{ [K in TKey] : string[] | undefined }>;
-/**
-* Verbose output flag preset.
-*
-* Adds: `-v, --verbose`
-* Resolves: `{ verbose: boolean }`
-*/
-declare function verbosePreset(): FlagPreset<{
-	verbose: boolean;
-}>;
-/**
-* Working directory flag preset.
-*
-* Adds: `--cwd <path>`
-* Resolves: `{ cwd: string }` (defaults to `process.cwd()`)
-*/
-declare function cwdPreset(): FlagPreset<{
-	cwd: string;
-}>;
-/**
-* Dry-run flag preset.
-*
-* Adds: `--dry-run`
-* Resolves: `{ dryRun: boolean }`
-*/
-declare function dryRunPreset(): FlagPreset<{
-	dryRun: boolean;
-}>;
-/**
-* Force flag preset.
-*
-* Adds: `-f, --force`
-* Resolves: `{ force: boolean }`
-*/
-declare function forcePreset(): FlagPreset<{
-	force: boolean;
-}>;
-/**
-* Interaction mode flag preset.
-*
-* Adds: `--non-interactive`, `--no-input`, `-y, --yes`
-* Resolves: `{ interactive: boolean, yes: boolean }`
-*
-* `interactive` defaults to `true` and is set to `false` when
-* `--non-interactive` or `--no-input` is passed. The two flags
-* are synonyms for user convenience.
-*/
-declare function interactionPreset(): FlagPreset<InteractionFlags>;
-/**
-* Strict mode flag preset.
-*
-* Adds: `--strict`
-* Resolves: `{ strict: boolean }`
-*/
-declare function strictPreset(): FlagPreset<StrictFlags>;
-/**
-* Color mode flag preset.
-*
-* Adds: `--color [mode]`, `--no-color`
-* Resolves: `{ color: "auto" | "always" | "never" }`
-*
-* Commander's `--no-color` negation sets `flags["color"]` to `false`,
-* which resolves to `"never"`. Invalid values default to `"auto"`.
-*
-* This preset resolves the user's *intent*. Consumers should compose
-* with terminal detection (`supportsColor()`, `resolveColorEnv()`)
-* to determine actual color output behavior.
-*/
-declare function colorPreset(): FlagPreset<ColorFlags>;
-/**
-* Projection flag preset.
-*
-* Adds: `--fields <fields>`, `--exclude-fields <fields>`, `--count`
-* Resolves: `{ fields: string[] | undefined, excludeFields: string[] | undefined, count: boolean }`
-*
-* Fields are parsed as comma-separated strings with whitespace trimming.
-* `undefined` when not provided (not empty array) to distinguish
-* "not specified" from "empty".
-*
-* Conflict between `--fields` and `--exclude-fields` is a handler
-* concern (documented, not enforced).
-*/
-declare function projectionPreset(): FlagPreset<ProjectionFlags>;
-/**
-* Time-window flag preset.
-*
-* Adds: `--since <date>`, `--until <date>`
-* Resolves: `{ since: Date | undefined, until: Date | undefined }`
-*
-* Accepts ISO 8601 dates (`2024-01-15`) or relative durations
-* (`7d`, `24h`, `30m`, `2w`). Durations are past-relative
-* (subtracted from now).
-*
-* Returns `undefined` for unparseable values (does not throw).
-* When `config.maxRange` is set and both bounds are provided,
-* ranges above the limit are treated as invalid.
-*/
-declare function timeWindowPreset(config?: TimeWindowPresetConfig): FlagPreset<TimeWindowFlags>;
-/**
-* Execution flag preset.
-*
-* Adds: `--timeout <ms>`, `--retries <n>`, `--offline`
-* Resolves: `{ timeout: number | undefined, retries: number, offline: boolean }`
-*
-* Timeout is parsed as a positive integer in milliseconds.
-* Retries are parsed as a non-negative integer, clamped to maxRetries.
-*/
-declare function executionPreset(config?: ExecutionPresetConfig): FlagPreset<ExecutionFlags>;
-/**
-* Pagination flag preset.
-*
-* Adds: `-l, --limit <n>`, `--next`, `--reset`
-* Resolves: `{ limit: number, next: boolean, reset: boolean }`
-*
-* Limit is parsed as an integer, clamped to maxLimit, and defaults
-* to defaultLimit on invalid input. Mutual exclusivity of --next
-* and --reset is a handler concern (not enforced here).
-*
-* Integrates with loadCursor/saveCursor/clearCursor from
-* `@outfitter/cli/pagination`.
-*/
-declare function paginationPreset(config?: PaginationPresetConfig): FlagPreset<PaginationFlags>;
-export { verbosePreset, timeWindowPreset, stringListFlagPreset, strictPreset, projectionPreset, paginationPreset, numberFlagPreset, interactionPreset, forcePreset, executionPreset, enumFlagPreset, dryRunPreset, cwdPreset, createPreset, composePresets, colorPreset, booleanFlagPreset, TimeWindowPresetConfig, TimeWindowFlags, StringListFlagPresetConfig, StrictFlags, ProjectionFlags, PaginationPresetConfig, PaginationFlags, NumberFlagPresetConfig, InteractionFlags, FlagPresetConfig, FlagPreset, ExecutionPresetConfig, ExecutionFlags, EnumFlagPresetConfig, ComposedPreset, ColorMode, ColorFlags, BooleanFlagPresetConfig };
+import { colorPreset, cwdPreset, dryRunPreset, executionPreset, forcePreset, interactionPreset, paginationPreset, projectionPreset, strictPreset, timeWindowPreset, verbosePreset } from "./shared/@outfitter/cli-xw8ys1je.js";
+import { composePresets, createPreset, createSchemaPreset, isSchemaPreset } from "./shared/@outfitter/cli-n54zs151.js";
+import { booleanFlagPreset, enumFlagPreset, numberFlagPreset, stringListFlagPreset } from "./shared/@outfitter/cli-dv8kk4jw.js";
+import { AnyPreset, BooleanFlagPresetConfig, ColorFlags, ColorMode, ComposedPreset, EnumFlagPresetConfig, ExecutionFlags, ExecutionPresetConfig, FlagPreset, FlagPresetConfig, InteractionFlags, NumberFlagPresetConfig, PaginationFlags, PaginationPresetConfig, ProjectionFlags, SchemaPreset, SchemaPresetConfig, StrictFlags, StringListFlagPresetConfig, TimeWindowFlags, TimeWindowPresetConfig } from "./shared/@outfitter/cli-x6qr7bnd.js";
+export { verbosePreset, timeWindowPreset, stringListFlagPreset, strictPreset, projectionPreset, paginationPreset, numberFlagPreset, isSchemaPreset, interactionPreset, forcePreset, executionPreset, enumFlagPreset, dryRunPreset, cwdPreset, createSchemaPreset, createPreset, composePresets, colorPreset, booleanFlagPreset, TimeWindowPresetConfig, TimeWindowFlags, StringListFlagPresetConfig, StrictFlags, SchemaPresetConfig, SchemaPreset, ProjectionFlags, PaginationPresetConfig, PaginationFlags, NumberFlagPresetConfig, InteractionFlags, FlagPresetConfig, FlagPreset, ExecutionPresetConfig, ExecutionFlags, EnumFlagPresetConfig, ComposedPreset, ColorMode, ColorFlags, BooleanFlagPresetConfig, AnyPreset };