instant-cli 1.0.23-branch-codex-cli-args-combinators.25394030897.1 → 1.0.23-branch-codex-cli-args-combinators.25395572961.1

package/src/commands/auth/origin/add.ts

@@ -95,8 +95,9 @@ const addOriginHandler = Effect.fn(function* (
 const handleGenericOrigin = Effect.fn(function* (
   opts: Record<string, unknown>,
 ) {
-  const url = yield* Args.text(opts, 'url').pipe(
-    Args.orPrompt({
+  const args = Args.from(opts);
+  const url = yield* args.text('url').pipe(
+    Args.prompt({
       prompt: 'Website URL:',
       placeholder: 'example.com',
       modifyOutput: UI.modifiers.piped([
@@ -120,8 +121,9 @@ const handleGenericOrigin = Effect.fn(function* (
 });
 
 const handleVercelOrigin = Effect.fn(function* (opts: Record<string, unknown>) {
-  const project = yield* Args.text(opts, 'project').pipe(
-    Args.orPrompt({
+  const args = Args.from(opts);
+  const project = yield* args.text('project').pipe(
+    Args.prompt({
       prompt: 'Vercel project name:',
       placeholder: 'vercel-project-name',
       modifyOutput: UI.modifiers.piped([
@@ -143,8 +145,9 @@ const handleVercelOrigin = Effect.fn(function* (opts: Record<string, unknown>) {
 const handleNetlifyOrigin = Effect.fn(function* (
   opts: Record<string, unknown>,
 ) {
-  const site = yield* Args.text(opts, 'site').pipe(
-    Args.orPrompt({
+  const args = Args.from(opts);
+  const site = yield* args.text('site').pipe(
+    Args.prompt({
       prompt: 'Netlify site name:',
       placeholder: 'netlify-site-name',
       modifyOutput: UI.modifiers.piped([
@@ -166,8 +169,9 @@ const handleNetlifyOrigin = Effect.fn(function* (
 const handleCustomSchemeOrigin = Effect.fn(function* (
   opts: Record<string, unknown>,
 ) {
-  const scheme = yield* Args.text(opts, 'scheme').pipe(
-    Args.orPrompt({
+  const args = Args.from(opts);
+  const scheme = yield* args.text('scheme').pipe(
+    Args.prompt({
       prompt: 'App scheme:',
       placeholder: 'app-scheme://',
       modifyOutput: UI.modifiers.piped([

package/src/lib/args.ts

@@ -4,30 +4,74 @@ import { GlobalOpts } from '../context/globalOpts.ts';
 import { UI } from '../ui/index.ts';
 import { runUIEffect } from './ui.ts';
 
-const ArgFlag: unique symbol = Symbol('ArgFlag');
-
-/**
- * An ArgEffect is just an Effect with the source CLI flag attached to it.
- *
- * Effect values do not have a natural place to store "this came from
- * --client-id", but the prompt/validation combinators need that flag name for
- * errors. The symbol keeps the metadata private to this module and prevents
- * these helpers from accepting arbitrary Effects.
- */
-export type ArgEffect<A, E = never, R = never> = Effect.Effect<A, E, R> & {
-  readonly [ArgFlag]: string;
+type ActiveArg<A, E, R> = {
+  readonly _tag: 'Active';
+  readonly provided: boolean;
+  readonly value: Effect.Effect<A | undefined, E, R>;
 };
 
-const flagName = (name: string) => (name.startsWith('--') ? name : `--${name}`);
+type InactiveArg = {
+  readonly _tag: 'Inactive';
+};
+
+type ArgState<A, E, R> = ActiveArg<A, E, R> | InactiveArg;
+
+export interface Arg<A, E = never, R = never> {
+  readonly flag: string;
+  readonly state: Effect.Effect<ArgState<A, E, R>, E, R>;
+  pipe(): Arg<A, E, R>;
+  pipe<B>(ab: (self: Arg<A, E, R>) => B): B;
+  pipe<B, C>(ab: (self: Arg<A, E, R>) => B, bc: (b: B) => C): C;
+  pipe<B, C, D>(
+    ab: (self: Arg<A, E, R>) => B,
+    bc: (b: B) => C,
+    cd: (c: C) => D,
+  ): D;
+  pipe<B, C, D, F>(
+    ab: (self: Arg<A, E, R>) => B,
+    bc: (b: B) => C,
+    cd: (c: C) => D,
+    df: (d: D) => F,
+  ): F;
+  pipe<B, C, D, F, G>(
+    ab: (self: Arg<A, E, R>) => B,
+    bc: (b: B) => C,
+    cd: (c: C) => D,
+    df: (d: D) => F,
+    fg: (f: F) => G,
+  ): G;
+}
+
+const keyName = (name: string) => name.replace(/^--/, '');
+
+const flagName = (name: string) => {
+  const key = keyName(name);
+  return key.startsWith('-') ? key : `--${key}`;
+};
 
 const makeArg = <A, E, R>(
   flag: string,
-  effect: Effect.Effect<A, E, R>,
-): ArgEffect<A, E, R> => {
-  return Object.assign(effect, { [ArgFlag]: flag }) as ArgEffect<A, E, R>;
+  state: Effect.Effect<ArgState<A, E, R>, E, R>,
+): Arg<A, E, R> => {
+  const arg: Arg<A, E, R> = {
+    flag,
+    state,
+    pipe: function pipe(
+      this: Arg<A, E, R>,
+      ...fns: Array<(value: unknown) => unknown>
+    ) {
+      return fns.reduce<unknown>((value, fn) => fn(value), this);
+    } as Arg<A, E, R>['pipe'],
+  };
+  return arg;
 };
 
-const getFlag = (arg: ArgEffect<unknown, unknown, unknown>) => arg[ArgFlag];
+const active = <A, E, R>(
+  value: Effect.Effect<A | undefined, E, R>,
+  provided: boolean,
+): ActiveArg<A, E, R> => ({ _tag: 'Active', provided, value });
+
+const inactive: InactiveArg = { _tag: 'Inactive' };
 
 const missingMessage = (flag: string) => `Missing required value for ${flag}`;
 
@@ -35,10 +79,47 @@ type MissingOptions = {
   message?: string;
 };
 
-function text(opts: Record<string, unknown>, name: string) {
-  const flag = flagName(name);
+type UnavailableOptions = {
+  message?: string;
+  otherwise?: string;
+};
+
+type ArgsReader = {
+  text: (name: string) => Arg<string, BadArgsError>;
+  bool: (name: string) => Arg<boolean, BadArgsError>;
+  has: (name: string) => boolean;
+  hasAny: (names: string[]) => boolean;
+  isTrue: (name: string) => boolean;
+  raw: (name: string) => unknown;
+};
+
+function from(opts: Record<string, unknown>): ArgsReader {
+  const raw = (name: string) => opts[keyName(name)];
+  const has = (name: string) =>
+    Object.prototype.hasOwnProperty.call(opts, keyName(name));
+
+  return {
+    text: (name) => text(opts, name),
+    bool: (name) => bool(opts, name),
+    has,
+    hasAny: (names) => names.some(has),
+    isTrue: (name) => {
+      const value = raw(name);
+      return value === true || value === 'true';
+    },
+    raw,
+  };
+}
 
-  return makeArg(flag, readTextValue(opts[name], flag));
+function text(opts: Record<string, unknown>, name: string) {
+  const key = keyName(name);
+  const flag = flagName(key);
+  const provided = Object.prototype.hasOwnProperty.call(opts, key);
+
+  return makeArg(
+    flag,
+    Effect.succeed(active(readTextValue(opts[key], flag), provided)),
+  );
 }
 
 function readTextValue(value: unknown, flag: string) {
@@ -57,9 +138,14 @@ function readTextValue(value: unknown, flag: string) {
 }
 
 function bool(opts: Record<string, unknown>, name: string) {
-  const flag = flagName(name);
-
-  return makeArg(flag, readBooleanValue(opts[name], flag));
+  const key = keyName(name);
+  const flag = flagName(key);
+  const provided = Object.prototype.hasOwnProperty.call(opts, key);
+
+  return makeArg(
+    flag,
+    Effect.succeed(active(readBooleanValue(opts[key], flag), provided)),
+  );
 }
 
 function readBooleanValue(value: unknown, flag: string) {
@@ -78,23 +164,49 @@ function uiErrorToBadArgs(e: { message: string }) {
   return BadArgsError.make({ message: `UI error: ${e.message}` });
 }
 
-function orPrompt(prompt: UI.TextInputProps) {
-  return function orPromptArg<E, R>(arg: ArgEffect<string | undefined, E, R>) {
-    return orPromptIf(true, prompt)(arg);
-  };
+function mapActive<A, B, E, R, E2, R2>(
+  arg: Arg<A, E, R>,
+  mapValue: (
+    value: Effect.Effect<A | undefined, E, R>,
+  ) => Effect.Effect<B | undefined, E | E2, R | R2>,
+): Arg<B, E | E2, R | R2> {
+  return makeArg(
+    arg.flag,
+    Effect.gen(function* mapArgState() {
+      const state = yield* arg.state;
+      if (state._tag === 'Inactive') return inactive;
+      return active(mapValue(state.value), state.provided);
+    }),
+  );
 }
 
-function orPromptIf(condition: boolean, prompt: UI.TextInputProps) {
-  return function orPromptIfArg<E, R>(
-    arg: ArgEffect<string | undefined, E, R>,
-  ) {
-    const flag = getFlag(arg);
-
+function availableWhen(condition: boolean, options?: UnavailableOptions) {
+  return function availableWhenArg<A, E, R>(arg: Arg<A, E, R>) {
     return makeArg(
-      flag,
+      arg.flag,
+      Effect.gen(function* gateArgAvailability() {
+        const state = yield* arg.state;
+        if (condition || state._tag === 'Inactive') return state;
+        if (state.provided) {
+          return yield* BadArgsError.make({
+            message:
+              options?.message ??
+              options?.otherwise ??
+              `${arg.flag} is not compatible with other options`,
+          });
+        }
+        return inactive;
+      }),
+    );
+  };
+}
+
+function prompt(prompt: UI.TextInputProps) {
+  return function promptArg<E, R>(arg: Arg<string, E, R>) {
+    return mapActive(arg, (valueEffect) =>
       Effect.gen(function* promptWhenMissing() {
-        const value = yield* arg;
-        if (value !== undefined || !condition) return value;
+        const value = yield* valueEffect;
+        if (value !== undefined) return value;
 
         const { yes } = yield* GlobalOpts;
         if (yes) return undefined;
@@ -109,25 +221,12 @@ function orPromptIf(condition: boolean, prompt: UI.TextInputProps) {
   };
 }
 
-function orConfirm(prompt: UI.ConfirmationProps) {
-  return function orConfirmArg<E, R>(
-    arg: ArgEffect<boolean | undefined, E, R>,
-  ) {
-    return orConfirmIf(true, prompt)(arg);
-  };
-}
-
-function orConfirmIf(condition: boolean, prompt: UI.ConfirmationProps) {
-  return function orConfirmIfArg<E, R>(
-    arg: ArgEffect<boolean | undefined, E, R>,
-  ) {
-    const flag = getFlag(arg);
-
-    return makeArg(
-      flag,
+function confirm(prompt: UI.ConfirmationProps) {
+  return function confirmArg<E, R>(arg: Arg<boolean, E, R>) {
+    return mapActive(arg, (valueEffect) =>
       Effect.gen(function* confirmWhenMissing() {
-        const value = yield* arg;
-        if (value !== undefined || !condition) return value;
+        const value = yield* valueEffect;
+        if (value !== undefined) return value;
 
         const { yes } = yield* GlobalOpts;
         if (yes) return undefined;
@@ -141,83 +240,39 @@ function orConfirmIf(condition: boolean, prompt: UI.ConfirmationProps) {
 }
 
 function required(options?: MissingOptions) {
-  return function requiredArg<A, E, R>(arg: ArgEffect<A | undefined, E, R>) {
-    const flag = getFlag(arg);
-
-    return makeArg(
-      flag,
-      Effect.gen(function* requireValue() {
-        const value = yield* arg;
-        if (value !== undefined) return value;
-
-        return yield* BadArgsError.make({
-          message: options?.message ?? missingMessage(flag),
-        });
-      }),
-    );
-  };
-}
-
-function requiredIf(condition: boolean, options?: MissingOptions) {
-  return function requiredIfArg<A, E, R>(
-    arg: ArgEffect<A | undefined, E, R>,
-  ): ArgEffect<A | undefined, E | BadArgsError, R> {
-    return condition ? required(options)(arg) : arg;
-  };
-}
+  return function requiredArg<A, E, R>(arg: Arg<A, E, R>) {
+    return Effect.gen(function* requireValue() {
+      const state = yield* arg.state;
+      if (state._tag === 'Inactive') return undefined as A;
 
-function forbidIf(condition: boolean, options?: { message?: string }) {
-  return function forbidIfArg<A, E, R>(arg: ArgEffect<A | undefined, E, R>) {
-    const flag = getFlag(arg);
+      const value = yield* state.value;
+      if (value !== undefined) return value;
 
-    return makeArg(
-      flag,
-      Effect.gen(function* rejectForbiddenValue() {
-        const value = yield* arg;
-        if (condition && value !== undefined) {
-          return yield* BadArgsError.make({
-            message:
-              options?.message ??
-              `${flag} is not compatible with other options`,
-          });
-        }
-
-        return condition ? undefined : value;
-      }),
-    );
+      return yield* BadArgsError.make({
+        message: options?.message ?? missingMessage(arg.flag),
+      });
+    });
   };
 }
 
-function validate<A>(validateValue: (value: A) => string | undefined) {
-  return function validateArg<E, R>(arg: ArgEffect<A | undefined, E, R>) {
-    const flag = getFlag(arg);
-
-    return makeArg(
-      flag,
-      Effect.gen(function* validateValueIfPresent() {
-        const value = yield* arg;
-        if (value === undefined) return undefined;
-
-        const error = validateValue(value);
-        if (error) {
-          return yield* BadArgsError.make({ message: error });
-        }
+function optional() {
+  return function optionalArg<A, E, R>(arg: Arg<A, E, R>) {
+    return Effect.gen(function* optionalValue() {
+      const state = yield* arg.state;
+      if (state._tag === 'Inactive') return undefined;
 
-        return value;
-      }),
-    );
+      return yield* state.value;
+    });
   };
 }
 
 export const Args = {
+  from,
   text,
   bool,
-  orPrompt,
-  orPromptIf,
-  orConfirm,
-  orConfirmIf,
+  availableWhen,
+  prompt,
+  confirm,
   required,
-  requiredIf,
-  forbidIf,
-  validate,
+  optional,
 };

package/src/lib/oauth.ts

@@ -253,14 +253,15 @@ export const getClientNameAndProvider = Effect.fn(function* (
   providerType: typeof ClientTypeSchema.Type,
   opts: Record<string, unknown>,
 ) {
+  const args = Args.from(opts);
   const { auth, provider } = yield* getOrCreateProvider(providerType);
   const usedClientNames = new Set(
     (auth.oauth_clients ?? []).map((client) => client.client_name),
   );
   const suggestedClientName = findName(providerType, usedClientNames);
 
-  const clientName = yield* Args.text(opts, 'name').pipe(
-    Args.orPrompt({
+  const clientName = yield* args.text('name').pipe(
+    Args.prompt({
       prompt: 'Client Name:',
       defaultValue: suggestedClientName,
       placeholder: suggestedClientName,