Prompt

import {
  text,
  password,
  confirm,
  select,
  multiselect,
  group,
  spinner,
  intro,
  outro,
  note,
  log,
  cancel,
  isCancel,
  CANCEL
} from '@bunli/runtime/prompt'

async function text<T = string>(
  message: string,
  options?: PromptOptions
): Promise<T>

import { text } from '@bunli/runtime/prompt'
import { z } from 'zod'

// Simple text input
const name = await text('What is your name?')

// With default value
const repo = await text('Repository name?', {
  default: 'my-project'
})

// With validation
const email = await text('Email address?', {
  validate: (input) => {
    if (!input.includes('@')) return 'Invalid email'
    return true
  }
})

// With schema validation
const port = await text<number>('Port number?', {
  schema: z.coerce.number().int().min(1).max(65535)
})

// Non-interactive with fallback
const apiKey = await text('API key?', {
  fallbackValue: process.env.API_KEY
})

async function password<T = string>(
  message: string,
  options?: PromptOptions
): Promise<T>

import { password } from '@bunli/runtime/prompt'

const secret = await password('Enter password:')

// With validation
const strongPassword = await password('Create password:', {
  validate: (input) => {
    if (input.length < 8) return 'Password must be at least 8 characters'
    return true
  }
})

async function confirm(
  message: string,
  options?: ConfirmOptions
): Promise<boolean>

import { confirm } from '@bunli/runtime/prompt'

const shouldContinue = await confirm('Continue?', {
  default: true
})

if (shouldContinue) {
  // proceed
}

async function select<T = string>(
  message: string,
  options: SelectOptions<T>
): Promise<T>

import { select } from '@bunli/runtime/prompt'

const framework = await select('Choose a framework:', {
  options: [
    { label: 'React', value: 'react', hint: 'Popular UI library' },
    { label: 'Vue', value: 'vue', hint: 'Progressive framework' },
    { label: 'Svelte', value: 'svelte', hint: 'Compiler-based' },
    { label: 'Angular', value: 'angular', disabled: true }
  ],
  default: 'react'
})

console.log(`Selected: ${framework}`)

async function multiselect<T = string>(
  message: string,
  options: MultiSelectOptions<T>
): Promise<T[]>

import { multiselect } from '@bunli/runtime/prompt'

const features = await multiselect('Select features:', {
  options: [
    { label: 'TypeScript', value: 'typescript' },
    { label: 'ESLint', value: 'eslint' },
    { label: 'Prettier', value: 'prettier' },
    { label: 'Tests', value: 'tests' }
  ],
  min: 1,
  initialValues: ['typescript']
})

console.log(`Selected: ${features.join(', ')}`)

async function group<T extends Record<string, () => Promise<unknown>>>(
  steps: T
): Promise<{ [K in keyof T]: Awaited<ReturnType<T[K]>> }>

import { group, text, select, confirm } from '@bunli/runtime/prompt'

const result = await group({
  name: () => text('Project name?'),
  framework: () => select('Framework?', {
    options: [
      { label: 'React', value: 'react' },
      { label: 'Vue', value: 'vue' }
    ]
  }),
  install: () => confirm('Install dependencies?')
})

// result is typed as:
// {
//   name: string
//   framework: string
//   install: boolean
// }

function spinner(options?: SpinnerOptions | string): Spinner

import { spinner } from '@bunli/runtime/prompt'

const s = spinner('Installing dependencies...')
s.start()

try {
  await installDeps()
  s.succeed('Dependencies installed!')
} catch (error) {
  s.fail('Installation failed')
}

// With timer
const s2 = spinner({
  text: 'Building project...',
  showTimer: true,
  animation: 'braille'
})
s2.start()
await build()
s2.succeed()

function intro(message: string): void

function outro(message: string): void

function note(message: string, title?: string): void

const log = {
  info(message: string): void
  success(message: string): void
  warn(message: string): void
  error(message: string): void
}

function cancel(message?: string): void

import { intro, outro, note, log } from '@bunli/runtime/prompt'

intro('Project Setup')

log.info('Starting installation...')
log.success('Installation complete')

note(`
Project: my-app
Framework: React
TypeScript: Yes
`, 'Configuration')

outro('Setup complete!')

function isCancel(value: unknown): value is Cancel

import { text, isCancel } from '@bunli/runtime/prompt'

const name = await text('Your name?')

if (isCancel(name)) {
  console.log('Cancelled!')
  process.exit(0)
}

console.log(`Hello, ${name}!`)

import { text, promptOrExit } from '@bunli/runtime/prompt'

const name = promptOrExit(
  await text('Your name?'),
  'Setup cancelled'
)

// name is guaranteed to be string, not Cancel