import { cli } from 'gunshi'

const args = process.argv.slice(2)
// run a simple command
await cli(args, () => {
  // something logic ...
  console.log('Hello from Gunshi!', args)
})

import { cli } from 'gunshi'

// define a command with declarative configuration, using commandable object
const command = {
  name: 'greet',
  description: 'A greeting command',
  options: {
    name: {
      type: 'string',
      short: 'n',
      description: 'Name to greet'
    },
    greeting: {
      type: 'string',
      short: 'g',
      default: 'Hello',
      description: 'Greeting to use (default: "Hello")'
    },
    times: {
      type: 'number',
      short: 't',
      default: 1,
      description: 'Number of times to repeat the greeting (default: 1)'
    }
  },
  run: ctx => {
    const { name = 'World', greeting, times } = ctx.values
    for (let i = 0; i < times; i++) {
      console.log(`${greeting}, ${name}!`)
    }
  }
}

// run a command that is defined above
// (the 3rd argument of `cli` is the command option)
await cli(process.argv.slice(2), command, {
  name: 'my-app',
  version: '1.0.0',
  description: 'My CLI application'
})

import { cli } from 'gunshi'

// define 'create' command
const createCommand = {
  name: 'create',
  description: 'Create a new resource',
  options: {
    name: { type: 'string', short: 'n' }
  },
  run: ctx => {
    console.log(`Creating resource: ${ctx.values.name}`)
  }
}

// define 'list' command
const listCommand = {
  name: 'list',
  description: 'List all resources',
  run: () => {
    console.log('Listing all resources...')
  }
}

// prepare a Map of sub-commands
const subCommands = new Map()
subCommands.set('create', createCommand)
subCommands.set('list', listCommand)

// define the main ('resource-manager') command
const mainCommand = {
  name: 'resource-manager',
  description: 'Manage resources',
  run: () => {
    console.log('Use one of the sub-commands: create, list')
  }
}

// run the CLI with composable sub-commands
await cli(process.argv.slice(2), mainCommand, {
  name: 'my-app',
  version: '1.0.0',
  subCommands
})

import { cli } from 'gunshi'

// define a command that will be loaded lazily
const lazyCommand = async () => {
  // simulate async loading
  await new Promise(resolve => setTimeout(resolve, 1000))

  // return the actual command
  return {
    name: 'lazy',
    description: 'A command that is loaded lazily',
    run: async ctx => {
      // async execution
      await new Promise(resolve => setTimeout(resolve, 500))
      console.log('Command executed!')
    }
  }
}

// prepare a Map of sub-commands with lazy-loaded commands
const subCommands = new Map()
subCommands.set('lazy', lazyCommand)

// run the CLI with lazy-loaded commands
await cli(
  process.argv.slice(2),
  { name: 'main', run: () => {} },
  {
    name: 'my-app',
    subCommands
  }
)

import { cli } from 'gunshi'

const command = {
  name: 'app',
  description: 'My application',
  options: {
    path: {
      type: 'string',
      short: 'p',
      description: 'File or directory path'
    },
    recursive: {
      type: 'boolean',
      short: 'r',
      description: 'Operate recursively on directories'
    },
    operation: {
      type: 'string',
      short: 'o',
      required: true,
      description: 'Operation to perform (list, copy, move, delete)'
    }
  },
  // define examples
  examples: '# Example\n$ my-app --operation list --path ./src',
  run: ctx => {
    // command implementation
  }
}

// run with --help to see the automatically generated usage information
await cli(process.argv.slice(2), command, {
  name: 'my-app',
  version: '1.0.0'
})

import { cli } from 'gunshi'

// define custom header renderer
const customHeaderRenderer = ctx => {
  return Promise.resolve(`
╔═══════════════════════╗
║      ${ctx.env.name.toUpperCase()}      ║
╚═══════════════════════╝
${ctx.env.description}
Version: ${ctx.env.version}
`)
}

// define custom usage renderer
const customUsageRenderer = ctx => {
  const lines = []
  lines.push('USAGE:')
  lines.push(`  $ ${ctx.env.name} [options]`)
  lines.push('')
  lines.push('OPTIONS:')

  for (const [key, option] of Object.entries(ctx.options || Object.create(null))) {
    const shortFlag = option.short ? `-${option.short}, ` : '    '
    lines.push(`  ${shortFlag}--${key.padEnd(10)} ${ctx.translate(key)}`)
  }

  return Promise.resolve(lines.join('\n'))
}

// run with custom renderers
await cli(
  process.argv.slice(2),
  { name: 'app', run: () => {} },
  {
    name: 'my-app',
    version: '1.0.0',
    description: 'My application',
    renderHeader: customHeaderRenderer,
    renderUsage: customUsageRenderer
  }
)

import { cli } from 'gunshi'
import enUS from './locales/en-US.json' with { type: 'json' }

const command = {
  name: 'greeter',
  options: {
    name: {
      type: 'string',
      short: 'n'
    },
    formal: {
      type: 'boolean',
      short: 'f'
    }
  },
  // resource fetcher for translations
  resource: async ctx => {
    if (ctx.locale.toString() === 'ja-JP') {
      const resource = await import('./locales/ja-JP.json', { with: { type: 'json' } })
      return resource.default
    }

    // default to English
    return enUS
  },
  run: ctx => {
    const { name = 'World', formal } = ctx.values
    const greeting = formal ? ctx.translate('formal_greeting') : ctx.translate('informal_greeting')
    console.log(`${greeting}, ${name}!`)
  }
}

// run with locale support
await cli(process.argv.slice(2), command, {
  name: 'my-app',
  version: '1.0.0',
  // set the locale via an environment variable
  // if Node v21 or later is used, you can use the built-in `navigator.language` instead)
  locale: new Intl.Locale(process.env.MY_LOCALE || 'en-US')
})