Prompting for Missing Values

import * as readline from 'node:readline';
import cliForge, { type PromptOption, type PromptProvider } from 'cli-forge';

// --- Simple readline-based prompt provider ---
// Reads answers line-by-line from stdin. Works for both interactive
// terminals and piped input (e.g. `printf "answer\n" | my-cli`).
//
// Note: When stdin is piped, readline eagerly consumes all lines.
// Successive `rl.question()` calls race with that consumption, so we
// buffer lines upfront when stdin is non-interactive and serve them
// to each prompt in order.

/**
 * Collect all lines from a readable stream, then return them.
 */
function readAllLines(stream: NodeJS.ReadableStream): Promise<string[]> {
  return new Promise((resolve) => {
    const lines: string[] = [];
    const rl = readline.createInterface({ input: stream });
    rl.on('line', (line) => lines.push(line));
    rl.on('close', () => resolve(lines));
  });
}

function createReadlinePromptProvider(): PromptProvider {
  return {
    async promptBatch(
      options: PromptOption[]
    ): Promise<Record<string, unknown>> {
      const isInteractive = !!(process.stdin as any).isTTY;

      // When piped, buffer all lines first to avoid the readline race.
      const bufferedLines = isInteractive
        ? null
        : await readAllLines(process.stdin);
      let lineIndex = 0;

      // For interactive mode, use question(); for piped mode, serve from buffer.
      let rl: readline.Interface | undefined;
      const ask = (query: string): Promise<string> => {
        if (bufferedLines) {
          process.stdout.write(query);
          return Promise.resolve(bufferedLines[lineIndex++] ?? '');
        }
        if (rl === undefined) {
          rl = readline.createInterface({
            input: process.stdin,
            output: process.stdout,
          });
        }
        return new Promise((resolve) => rl!.question(query, resolve));
      };

      const results: Record<string, unknown> = {};
      try {
        for (const option of options) {
          // Use custom prompt label, description, or fall back to the option name
          const label =
            typeof option.config.prompt === 'string'
              ? option.config.prompt
              : option.config.description ?? option.name;

          const answer = await ask(`${label}: `);

          // Coerce the raw string to the expected option type
          if (option.config.type === 'number') {
            results[option.name] = Number(answer);
          } else if (option.config.type === 'boolean') {
            results[option.name] =
              answer.toLowerCase() === 'true' || answer === '1';
          } else {
            results[option.name] = answer;
          }
        }
      } finally {
        rl?.close();
      }

      return results;
    },
  };
}

// --- CLI definition ---

const cli = cliForge('prompting-demo')
  // Register the prompt provider. When required options are missing,
  // cli-forge will delegate to this provider to collect values.
  .withPromptProvider(createReadlinePromptProvider())
  .command('$0', {
    builder: (args) =>
      args
        .option('name', {
          type: 'string',
          description: 'Your name',
          // Required options without a default are auto-prompted when
          // a provider is registered and no value was given on the CLI.
          required: true,
        })
        .option('greeting', {
          type: 'string',
          description: 'The greeting to use',
          // Optional with a default — never prompted automatically.
          default: 'Hello',
        })
        .option('age', {
          type: 'number',
          description: 'Your age',
          required: true,
        }),
    handler: (args) => {
      console.log(
        `${args.greeting}, ${args.name}! You are ${args.age} years old.`
      );
    },
  });

export default cli;

if (require.main === module) {
  (async () => {
    await cli.forge();
  })();
}