@stacksjs/cli 0.64.6 → 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) {
-  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,47 +0,0 @@
-import type { CliOptions } 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) => {
-    return await runCommand(command, options)
-  },
-
-  runSync: async (command: string, options?: CliOptions) => {
-    return await runCommand(command, options)
-  },
-}

package/src/console.ts

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

package/src/exec.ts

@@ -1,122 +0,0 @@
-import process from 'node:process'
-import { type Result, err, handleError, ok } from '@stacksjs/error-handling'
-import type { CliOptions, Subprocess } from '@stacksjs/types'
-import { ExitCode } from '@stacksjs/types'
-import { 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, exitCode, signalCode, error) {
-      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: ${cmd.join(' ')}`))
-}
-
-/**
- * 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, exitCode, signalCode, error) {
-      exitHandler('spawnSync', subprocess, exitCode, signalCode, error)
-    },
-  })
-
-  return proc.stdout.toString()
-}
-
-// @ts-expect-error - missing types is okay here but can be improved later on
-function exitHandler(type: 'spawn' | 'spawnSync', subprocess, exitCode, signalCode, 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,69 +0,0 @@
-import { handleError } from '@stacksjs/error-handling'
-import { log } from '@stacksjs/logging'
-import type { IntroOptions, OutroOptions } from '@stacksjs/types'
-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) {
-  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 './helpers'
-export * from './parse'
-export * from './exec'
-export * from './run'
-export * from './spinner'
-export * from './utils'

package/src/parse.ts

@@ -1,170 +0,0 @@
-import process from 'node:process'
-import { log } from '@stacksjs/logging'
-
-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 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) {
-        // if the next arg exists
-        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 options has no keys, return undefined, e.g. `buddy release`
-  if (Object.keys(options).length === 0) return { dryRun: false, quiet: false, verbose: false }
-
-  // convert the string 'true' or 'false' to a boolean
-  Object.keys(options).forEach((key) => {
-    if (!options) return { dryRun: false, quiet: false, verbose: false }
-
-    const value = options[key]
-
-    if (value === 'true' || value === 'false') options[key] = value === 'true'
-  })
-
-  return options
-}
-// interface BuddyOptions {
-//   dryRun?: boolean
-//   verbose?: boolean
-// }
-export function buddyOptions(options?: any): string {
-  if (!options) {
-    options = process.argv.slice(2)
-    options = Array.from(new Set(options))
-    // delete the 0 element if it does not start with a -
-    // e.g. is used when buddy changelog --dry-run is used
-    if (options[0] && !options[0].startsWith('-')) options.shift()
-  }
-
-  if (options?.verbose) {
-    log.debug('process.argv', process.argv)
-    log.debug('process.argv.slice(2)', process.argv.slice(2))
-    log.debug('options inside buddyOptions', options)
-  }
-
-  return options.join(' ')
-}

package/src/run.ts

@@ -1,108 +0,0 @@
-import type { Result } from '@stacksjs/error-handling'
-import type { CliOptions, CommandError, Subprocess } from '@stacksjs/types'
-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) {
-  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 = ora

package/src/utils.ts

@@ -1,83 +0,0 @@
-import { collect } from '@stacksjs/collections'
-
-export * as kolorist from 'kolorist'
-
-export {
-  stripAnsi,
-  centerAlign,
-  rightAlign,
-  leftAlign,
-  align,
-  box,
-  colors,
-  getColor,
-  colorize,
-} from 'consola/utils'
-
-export {
-  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,
-  underline,
-  white,
-  yellow,
-  ansi256,
-  trueColor,
-  trueColorBg,
-  stripColors,
-} from 'kolorist'
-
-export const quotes = 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.',
-])