@stacksjs/cli 0.65.0 → 0.67.0

package/src/cli.ts

@@ -1,30 +0,0 @@
-// import type { CliOptions } from '@stacksjs/types'
-import { CAC } from 'cac'
-
-export interface ParsedArgv {
-  args: ReadonlyArray<string>
-  options: {
-    [k: string]: any
-  }
-}
-
-interface CliOptions {
-  name?: string
-  // version: string
-  // description: string
-}
-
-export function cli(name?: string | CliOptions, options?: CliOptions): CAC {
-  if (typeof name === 'object') {
-    options = name
-    name = options.name
-  }
-
-  return new CAC(name || 'buddy')
-}
-
-export { CAC }
-
-// export function command(name: string, description: string, options?: CliOptions) {
-//   return cli(options).command(name, description)
-// }

package/src/command.ts

@@ -1,54 +0,0 @@
-import type { Result } from '@stacksjs/error-handling'
-import type { CliOptions, Readable, Subprocess, Writable } from '@stacksjs/types'
-import { runCommand } from './run'
-
-type CommandOptionTuple = [string, string, { default: boolean }]
-interface CommandOptionObject {
-  name: string
-  description: string
-  default: boolean | string
-}
-type CommandOptions = CommandOptionTuple | CommandOptionObject[]
-interface Options {
-  name: string
-  description: string
-  active: boolean
-  options: CommandOptions
-  run: (options?: CliOptions) => Promise<any>
-  onFail: (error: Error) => void
-  onSuccess: () => void
-}
-
-export class Command {
-  name: Options['name']
-  description: Options['description']
-  options: Options['options']
-  run: Options['run']
-  onFail: Options['onFail']
-  onSuccess: Options['onSuccess']
-
-  constructor({ name, description, options, run, onFail, onSuccess }: Options) {
-    this.name = name
-    this.description = description
-    this.options = options
-    this.run = run
-    this.onFail = onFail
-    this.onSuccess = onSuccess
-  }
-}
-
-export const command = {
-  run: async (
-    command: string,
-    options?: CliOptions,
-  ): Promise<Result<Subprocess<Writable, Readable, Readable>, Error>> => {
-    return await runCommand(command, options)
-  },
-
-  runSync: async (
-    command: string,
-    options?: CliOptions,
-  ): Promise<Result<Subprocess<Writable, Readable, Readable>, Error>> => {
-    return await runCommand(command, options)
-  },
-}

package/src/console.ts

@@ -1,4 +0,0 @@
-import { log } from '@stacksjs/logging'
-import prompts from 'prompts'
-
-export { log, prompts }

package/src/exec.ts

@@ -1,140 +0,0 @@
-import type { CliOptions, ErrorLike, SpawnOptions, Subprocess } from '@stacksjs/types'
-import process from 'node:process'
-import { err, handleError, ok, type Result } from '@stacksjs/error-handling'
-import { ExitCode } from '@stacksjs/types'
-import { italic, log } from './'
-
-/**
- * Execute a command.
- *
- * @param command The command to execute.
- * @param options The options to pass to the command.
- * @returns The result of the command.
- * @example
- * ```ts
- * const result = await exec('ls')
- *
- * if (result.isErr())
- *   console.error(result.error)
- * else
- *   console.log(result)
- * ```
- * @example
- * ```ts
- * const result = await exec('ls', { cwd: '/home' })
- * ```
- */
-export async function exec(command: string | string[], options?: CliOptions): Promise<Result<Subprocess, Error>> {
-  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]|"[^"]*")+/g)
-
-  if (!cmd)
-    return err(handleError(`Failed to parse command: ${cmd}`, options))
-
-  log.debug('exec:', Array.isArray(command) ? command.join(' ') : command)
-  log.debug('cmd:', cmd)
-  log.debug('exec options:', options)
-
-  const cwd = options?.cwd ?? process.cwd()
-  const proc = Bun.spawn(cmd, {
-    ...options,
-    stdout:
-      options?.silent || options?.quiet ? 'ignore' : options?.stdin ? options.stdin : options?.stdout || 'inherit',
-    stderr: options?.silent || options?.quiet ? 'ignore' : options?.stderr || 'inherit',
-    detached: options?.background || false,
-    cwd,
-    // env: { ...e, ...options?.env },
-    onExit(
-      subprocess: Subprocess<SpawnOptions.Writable, SpawnOptions.Readable, SpawnOptions.Readable>,
-      exitCode: number | null,
-      signalCode: number | null,
-      error: ErrorLike | undefined,
-    ) {
-      exitHandler('spawn', subprocess, exitCode, signalCode, error)
-    },
-  })
-
-  // Check if we need to write to stdin
-  // this is currently only used for `buddy aws:configure`
-  if (options?.stdin === 'pipe' && options.input) {
-    if (proc.stdin) {
-      // @ts-expect-error - this works even though there is a type error
-      proc.stdin.write(options.input)
-      // @ts-expect-error - this works even though there is a type error
-      proc.stdin.end()
-    }
-  }
-
-  const exited = await proc.exited
-  if (exited === ExitCode.Success)
-    return ok(proc)
-
-  return err(handleError(`Failed to execute command: ${italic(cmd.join(' '))} in ${italic(cwd)}`, options))
-}
-
-/**
- * Execute a command and return result.
- *
- * @param command The command to execute.
- * @returns The result of the command.
- * @example
- * ```ts
- * const output = execSync('ls')
- *
- * console.log(output)
- * ```
- * @example
- * ```ts
- * const output = execSync('ls', { cwd: '/home' })
- * ```
- */
-export async function execSync(command: string | string[], options?: CliOptions): Promise<string> {
-  log.debug('Running ExecSync:', command)
-  log.debug('ExecSync Options:', options)
-
-  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]|"[^"]*")+/g)
-
-  if (!cmd) {
-    log.error(`Failed to parse command: ${cmd}`, options)
-    process.exit(ExitCode.FatalError)
-  }
-
-  const proc = Bun.spawnSync(cmd, {
-    ...options,
-    stdin: options?.stdin ?? 'inherit',
-    stdout: options?.stdout ?? 'pipe',
-    stderr: options?.stderr ?? 'inherit',
-    cwd: options?.cwd ?? process.cwd(),
-    // env: { ...Bun.env, ...options?.env },
-    onExit(
-      subprocess: Subprocess<SpawnOptions.Writable, SpawnOptions.Readable, SpawnOptions.Readable>,
-      exitCode: number | null,
-      signalCode: number | null,
-      error: ErrorLike | undefined,
-    ) {
-      exitHandler('spawnSync', subprocess, exitCode, signalCode, error)
-    },
-  })
-
-  return proc.stdout?.toString() ?? ''
-}
-
-function exitHandler(
-  type: 'spawn' | 'spawnSync',
-  subprocess: Subprocess,
-  exitCode: number | null,
-  signalCode: number | null,
-  error?: Error,
-) {
-  log.debug(`exitHandler: ${type}`)
-  log.debug('subprocess', subprocess)
-  log.debug('exitCode', exitCode)
-  log.debug('signalCode', signalCode)
-
-  if (error) {
-    log.error(error)
-    process.exit(ExitCode.FatalError)
-  }
-
-  if (exitCode !== ExitCode.Success && exitCode)
-    process.exit(exitCode)
-}

package/src/helpers.ts

@@ -1,79 +0,0 @@
-import type { IntroOptions, OutroOptions } from '@stacksjs/types'
-import { handleError } from '@stacksjs/error-handling'
-import { log } from '@stacksjs/logging'
-import { ExitCode } from '@stacksjs/types'
-import { bgCyan, bold, cyan, dim, gray, green, italic } from 'kolorist'
-import { version } from '../package.json'
-
-/**
- * Prints the intro message.
- */
-export async function intro(command: string, options?: IntroOptions): Promise<number> {
-  return new Promise((resolve) => {
-    if (options?.quiet === false) {
-      console.log()
-      console.log(cyan(bold('Stacks CLI')) + dim(` v${version}`))
-      console.log()
-    }
-
-    log.info(`Running  ${bgCyan(italic(bold(` ${command} `)))}`)
-
-    if (options?.showPerformance === false || options?.quiet)
-      return resolve(0)
-
-    return resolve(performance.now())
-  })
-}
-
-/**
- * Prints the outro message.
- */
-export function outro(text: string, options?: OutroOptions, error?: Error | string): Promise<number> {
-  const opts = {
-    type: 'success',
-    useSeconds: true,
-    ...options,
-  }
-
-  opts.message = options?.message || text
-
-  return new Promise((resolve) => {
-    if (error)
-      return handleError(error)
-
-    if (opts?.startTime) {
-      let time = performance.now() - opts.startTime
-
-      if (opts.useSeconds) {
-        time = time / 1000
-        time = Math.round(time * 100) / 100 // https://stackoverflow.com/a/11832950/7811162
-      }
-
-      if (opts.quiet === true)
-        return resolve(ExitCode.Success)
-
-      if (error) {
-        log.error(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}] Failed`)
-      }
-      else if (opts.type === 'info') {
-        log.info(`${dim(gray(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}]`))} ${opts.message ?? 'Complete'}`)
-      }
-      else {
-        log.success(
-          `${dim(gray(bold(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}]`)))} ${bold(
-            green(opts.message ?? 'Complete'),
-          )}`,
-        )
-      }
-    }
-    else {
-      if (opts?.type === 'info')
-        log.info(text)
-      // the following condition triggers in the case of "Cleaned up" messages
-      else if (opts?.type === 'success' && opts?.quiet !== true)
-        log.success(text)
-    }
-
-    return resolve(ExitCode.Success)
-  })
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './actions'
-export * from './cli'
-export * from './command'
-export * from './console'
-export * from './exec'
-export * from './helpers'
-export * from './parse'
-export * from './run'
-export * from './spinner'
-export * from './utils'

package/src/parse.ts

@@ -1,182 +0,0 @@
-import process from 'node:process'
-
-interface ParsedArgv {
-  args: string[]
-  options: {
-    [k: string]: string | boolean | number
-  }
-}
-
-function isLongOption(arg?: string): boolean {
-  if (!arg)
-    return false
-
-  return arg.startsWith('--')
-}
-
-function isShortOption(arg: string): boolean {
-  return arg.startsWith('-') && !isLongOption(arg)
-}
-
-function parseValue(value: string): string | boolean | number {
-  if (value === 'true')
-    return true
-
-  if (value === 'false')
-    return false
-
-  const numberValue = Number.parseFloat(value)
-  if (!Number.isNaN(numberValue))
-    return numberValue
-
-  return value.replace(/"/g, '')
-}
-
-function parseLongOption(
-  arg: string,
-  argv: string[],
-  index: number,
-  options: { [k: string]: string | boolean | number },
-): number {
-  const [key, value] = arg.slice(2).split('=')
-  if (value !== undefined) {
-    options[key as string] = parseValue(value)
-  }
-  else if (index + 1 < argv.length && !argv[index + 1]?.startsWith('-')) {
-    options[key as string] = argv[index + 1] as string
-    index++
-  }
-  else {
-    options[key as string] = true
-  }
-  return index
-}
-
-function parseShortOption(
-  arg: string,
-  argv: string[],
-  index: number,
-  options: { [k: string]: string | boolean | number },
-): number {
-  const [key, value] = arg.slice(1).split('=')
-
-  // Check if key is undefined and handle it
-  if (key === undefined)
-    return index
-
-  if (value !== undefined && key !== undefined) {
-    for (let j = 0; j < key.length; j++) options[key[j] as string] = parseValue(value)
-  }
-  else {
-    for (let j = 0; j < key.length; j++) {
-      if (index + 1 < argv.length && j === key.length - 1 && !argv[index + 1]?.startsWith('-')) {
-        options[key[j] as string] = parseValue(argv[index + 1] as string)
-        index++
-      }
-      else {
-        options[key[j] as string] = true
-      }
-    }
-  }
-
-  return index
-}
-
-export function parseArgv(argv?: string[]): ParsedArgv {
-  if (argv === undefined)
-    argv = process.argv.slice(2)
-
-  const args: string[] = []
-  const options: { [k: string]: string | boolean | number } = {}
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i]
-    if (!arg)
-      continue
-    if (isLongOption(arg))
-      i = parseLongOption(arg, argv, i, options)
-    else if (isShortOption(arg))
-      i = parseShortOption(arg, argv, i, options)
-    else args.push(arg)
-  }
-
-  return { args, options }
-}
-
-export function parseArgs(argv?: string[]): string[] {
-  if (argv === undefined)
-    argv = process.argv.slice(2)
-
-  return parseArgv(argv).args
-}
-
-interface CliOptions {
-  dryRun?: boolean
-  quiet?: boolean
-  verbose?: boolean
-  [k: string]: string | boolean | number | undefined
-}
-
-export function parseOptions(options?: CliOptions): CliOptions {
-  options = options || {}
-  const defaults = { dryRun: false, quiet: false, verbose: false }
-  const args = process.argv.slice(2)
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]
-    if (arg?.startsWith('--')) {
-      const key = arg.substring(2) // remove the --
-      const camelCaseKey = key.replace(
-        /-([a-z])/gi,
-        g => (g[1] ? g[1].toUpperCase() : ''), // convert kebab-case to camelCase
-      )
-
-      if (i + 1 < args.length && !args?.[i + 1]?.startsWith('--')) {
-        // if the next arg exists and is not an option
-        if (args?.[i + 1] === 'true' || args?.[i + 1] === 'false') {
-          // if the next arg is a boolean
-          options[camelCaseKey] = args[i + 1] === 'true' // set the value to the boolean
-          i++
-        }
-        else {
-          options[camelCaseKey] = args[i + 1]
-          i++
-        }
-      }
-      else {
-        options[camelCaseKey] = true
-      }
-    }
-  }
-
-  if (Object.keys(options).length === 0)
-    // if options has no keys, return an empty object
-    return {}
-
-  return { ...defaults, ...options }
-}
-
-// interface BuddyOptions {
-//   dryRun?: boolean
-//   verbose?: boolean
-// }
-export function buddyOptions(options?: string[] | Record<string, any>): string {
-  if (Array.isArray(options)) {
-    options = Array.from(new Set(options)) as string[]
-    if (Array.isArray(options) && options[0] && !options[0].startsWith('-'))
-      options.shift()
-    return options.join(' ')
-  }
-
-  if (typeof options === 'object' && options !== null) {
-    return Object.entries(options)
-      .map(([key, value]) => {
-        if (value === true)
-          return `--${key}`
-        return `--${key} ${value}`
-      })
-      .join(' ')
-  }
-
-  return buddyOptions(process.argv.slice(2))
-}

package/src/run.ts

@@ -1,112 +0,0 @@
-import type { Ok, Result } from '@stacksjs/error-handling'
-import type { CliOptions, CommandError, Readable, Subprocess, Writable } from '@stacksjs/types'
-import process from 'node:process'
-import { ExitCode } from '@stacksjs/types'
-import { log } from './console'
-import { exec, execSync } from './exec'
-import { italic } from './utils'
-
-/**
- * Run a command.
- *
- * @param command The command to run.
- * @param options The options to pass to the command.
- * @returns The result of the command.
- * @example
- * ```ts
- * const result = await runCommand('ls')
- *
- * if (result.isErr())
- *   console.error(result.error)
- * else
- *   console.log(result)
- * ```
- * @example
- * ```ts
- * const result = await runCommand('ls', { cwd: '/home' })
- *
- * if (result.isErr())
- *   console.error(result.error)
- * else
- *   console.log(result)
- * ```
- */
-export async function runCommand(command: string, options?: CliOptions): Promise<Result<Subprocess, CommandError>> {
-  log.debug('runCommand:', command)
-  log.debug('options:', options)
-
-  return await exec(command, options)
-}
-
-export async function runProcess(command: string, options?: CliOptions): Promise<Result<Subprocess, CommandError>> {
-  log.debug('runProcess:', italic(command))
-  log.debug('runProcess Options:', options)
-
-  return await exec(command, options)
-}
-
-/**
- * Run a command.
- *
- * @param command The command to run.
- * @param options The options to pass to the command.
- * @returns The result of the command.
- * @example
- * ```ts
- * const result = runCommandSync('ls')
- *
- * if (result.isErr())
- *   console.error(result.error)
- * else
- *   console.log(result)
- * ```
- * @example
- * ```ts
- * const result = runCommandSync('ls', { cwd: '/home' })
- *
- * if (result.isErr())
- *   console.error(result.error)
- * else
- *   console.log(result)
- * ```
- */
-export async function runCommandSync(command: string, options?: CliOptions): Promise<string> {
-  log.debug('runCommandSync:', italic(command))
-  log.debug('runCommandSync Options:', options)
-
-  const result = await execSync(command, options)
-
-  // if (result.isErr())
-  //   return err(result.error)
-
-  // return ok(result.value)
-
-  return result
-}
-
-/**
- * Run many commands.
- *
- * @param commands The command to run.
- * @param options The options to pass to the command.
- * @returns The result of the command.
- */
-export async function runCommands(
-  commands: string[],
-  options?: CliOptions,
-): Promise<Ok<Subprocess<Writable, Readable, Readable>, Error>[]> {
-  const results = []
-
-  for (const command of commands) {
-    const result = await runCommand(command, options)
-
-    if (result.isErr()) {
-      log.error(result.error)
-      process.exit(ExitCode.FatalError)
-    }
-
-    results.push(result)
-  }
-
-  return results
-}

package/src/spinner.ts

@@ -1,3 +0,0 @@
-import ora from 'ora'
-
-export const spinner: typeof ora = ora

package/src/utils.ts

@@ -1,83 +0,0 @@
-import { collect, type Collection } from '@stacksjs/collections'
-
-export {
-  align,
-  box,
-  centerAlign,
-  colorize,
-  colors,
-  getColor,
-  leftAlign,
-  rightAlign,
-  stripAnsi,
-} from 'consola/utils'
-
-export * as kolorist from 'kolorist'
-
-export {
-  ansi256,
-  ansi256Bg,
-  bgBlack,
-  bgBlue,
-  bgCyan,
-  bgGray,
-  bgGreen,
-  bgLightBlue,
-  bgLightCyan,
-  bgLightGray,
-  bgLightGreen,
-  bgLightMagenta,
-  bgLightRed,
-  bgLightYellow,
-  bgMagenta,
-  bgRed,
-  bgWhite,
-  bgYellow,
-  black,
-  blue,
-  bold,
-  cyan,
-  dim,
-  gray,
-  green,
-  hidden,
-  inverse,
-  italic,
-  lightBlue,
-  lightCyan,
-  lightGray,
-  lightGreen,
-  lightMagenta,
-  lightRed,
-  lightYellow,
-  link,
-  magenta,
-  red,
-  reset,
-  strikethrough,
-  stripColors,
-  trueColor,
-  trueColorBg,
-  underline,
-  white,
-  yellow,
-} from 'kolorist'
-
-export const quotes: Collection<string> = collect([
-  // could be queried from any API or database
-  'The best way to get started is to quit talking and begin doing.',
-  'The pessimist sees difficulty in every opportunity. The optimist sees opportunity in every difficulty.',
-  'Don’t let yesterday take up too much of today.',
-  'You learn more from failure than from success. Don’t let it stop you. Failure builds character.',
-  'It’s not whether you get knocked down, it’s whether you get up.',
-  'If you are working on something that you really care about, you don’t have to be pushed. The vision pulls you.',
-  'People who are crazy enough to think they can change the world, are the ones who do.',
-  'Failure will never overtake me if my determination to succeed is strong enough.',
-  'Entrepreneurs are great at dealing with uncertainty and also very good at minimizing risk. That’s the classic entrepreneur.',
-  'We may encounter many defeats but we must not be defeated.',
-  'Knowing is not enough; we must apply. Wishing is not enough; we must do.',
-  'Imagine your life is perfect in every respect; what would it look like?',
-  'We generate fears while we sit. We overcome them by action.',
-  'Whether you think you can or think you can’t, you’re right.',
-  'Security is mostly a superstition. Life is either a daring adventure or nothing.',
-])