@stacksjs/cli 0.64.6 → 0.65.0

package/src/exec.ts

@@ -1,8 +1,8 @@
+import type { CliOptions, ErrorLike, SpawnOptions, Subprocess } from '@stacksjs/types'
 import process from 'node:process'
-import { type Result, err, handleError, ok } from '@stacksjs/error-handling'
-import type { CliOptions, Subprocess } from '@stacksjs/types'
+import { err, handleError, ok, type Result } from '@stacksjs/error-handling'
 import { ExitCode } from '@stacksjs/types'
-import { log } from './'
+import { italic, log } from './'
 
 /**
  * Execute a command.
@@ -25,15 +25,16 @@ import { log } from './'
  * ```
  */
 export async function exec(command: string | string[], options?: CliOptions): Promise<Result<Subprocess, Error>> {
-  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]+|"[^"]*")+/g)
+  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]|"[^"]*")+/g)
 
-  if (!cmd) return err(handleError(`Failed to parse command: ${cmd}`, options))
+  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 cwd = options?.cwd ?? process.cwd()
   const proc = Bun.spawn(cmd, {
     ...options,
     stdout:
@@ -42,7 +43,12 @@ export async function exec(command: string | string[], options?: CliOptions): Pr
     detached: options?.background || false,
     cwd,
     // env: { ...e, ...options?.env },
-    onExit(subprocess, exitCode, signalCode, error) {
+    onExit(
+      subprocess: Subprocess<SpawnOptions.Writable, SpawnOptions.Readable, SpawnOptions.Readable>,
+      exitCode: number | null,
+      signalCode: number | null,
+      error: ErrorLike | undefined,
+    ) {
       exitHandler('spawn', subprocess, exitCode, signalCode, error)
     },
   })
@@ -59,9 +65,10 @@ export async function exec(command: string | string[], options?: CliOptions): Pr
   }
 
   const exited = await proc.exited
-  if (exited === ExitCode.Success) return ok(proc)
+  if (exited === ExitCode.Success)
+    return ok(proc)
 
-  return err(handleError(`Failed to execute command: ${cmd.join(' ')}`))
+  return err(handleError(`Failed to execute command: ${italic(cmd.join(' '))} in ${italic(cwd)}`, options))
 }
 
 /**
@@ -84,7 +91,7 @@ export async function execSync(command: string | string[], options?: CliOptions)
   log.debug('Running ExecSync:', command)
   log.debug('ExecSync Options:', options)
 
-  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]+|"[^"]*")+/g)
+  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]|"[^"]*")+/g)
 
   if (!cmd) {
     log.error(`Failed to parse command: ${cmd}`, options)
@@ -98,16 +105,26 @@ export async function execSync(command: string | string[], options?: CliOptions)
     stderr: options?.stderr ?? 'inherit',
     cwd: options?.cwd ?? process.cwd(),
     // env: { ...Bun.env, ...options?.env },
-    onExit(subprocess, exitCode, signalCode, error) {
+    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()
+  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) {
+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)
@@ -118,5 +135,6 @@ function exitHandler(type: 'spawn' | 'spawnSync', subprocess, exitCode, signalCo
     process.exit(ExitCode.FatalError)
   }
 
-  if (exitCode !== ExitCode.Success && exitCode) process.exit(exitCode)
+  if (exitCode !== ExitCode.Success && exitCode)
+    process.exit(exitCode)
 }

package/src/helpers.ts

@@ -1,6 +1,6 @@
+import type { IntroOptions, OutroOptions } from '@stacksjs/types'
 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'
@@ -18,7 +18,8 @@ export async function intro(command: string, options?: IntroOptions): Promise<nu
 
     log.info(`Running  ${bgCyan(italic(bold(` ${command} `)))}`)
 
-    if (options?.showPerformance === false || options?.quiet) return resolve(0)
+    if (options?.showPerformance === false || options?.quiet)
+      return resolve(0)
 
     return resolve(performance.now())
   })
@@ -27,7 +28,7 @@ export async function intro(command: string, options?: IntroOptions): Promise<nu
 /**
  * Prints the outro message.
  */
-export function outro(text: string, options?: OutroOptions, error?: Error | string) {
+export function outro(text: string, options?: OutroOptions, error?: Error | string): Promise<number> {
   const opts = {
     type: 'success',
     useSeconds: true,
@@ -37,7 +38,8 @@ export function outro(text: string, options?: OutroOptions, error?: Error | stri
   opts.message = options?.message || text
 
   return new Promise((resolve) => {
-    if (error) return handleError(error)
+    if (error)
+      return handleError(error)
 
     if (opts?.startTime) {
       let time = performance.now() - opts.startTime
@@ -47,21 +49,29 @@ export function outro(text: string, options?: OutroOptions, error?: Error | stri
         time = Math.round(time * 100) / 100 // https://stackoverflow.com/a/11832950/7811162
       }
 
-      if (opts.quiet === true) return resolve(ExitCode.Success)
+      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')
+      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
+      }
+      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)
+      }
+    }
+    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)
+      else if (opts?.type === 'success' && opts?.quiet !== true)
+        log.success(text)
     }
 
     return resolve(ExitCode.Success)

package/src/index.ts

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

package/src/parse.ts

@@ -1,5 +1,4 @@
 import process from 'node:process'
-import { log } from '@stacksjs/logging'
 
 interface ParsedArgv {
   args: string[]
@@ -9,7 +8,8 @@ interface ParsedArgv {
 }
 
 function isLongOption(arg?: string): boolean {
-  if (!arg) return false
+  if (!arg)
+    return false
 
   return arg.startsWith('--')
 }
@@ -19,12 +19,15 @@ function isShortOption(arg: string): boolean {
 }
 
 function parseValue(value: string): string | boolean | number {
-  if (value === 'true') return true
+  if (value === 'true')
+    return true
 
-  if (value === 'false') return false
+  if (value === 'false')
+    return false
 
   const numberValue = Number.parseFloat(value)
-  if (!Number.isNaN(numberValue)) return numberValue
+  if (!Number.isNaN(numberValue))
+    return numberValue
 
   return value.replace(/"/g, '')
 }
@@ -38,10 +41,12 @@ function parseLongOption(
   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('-')) {
+  }
+  else if (index + 1 < argv.length && !argv[index + 1]?.startsWith('-')) {
     options[key as string] = argv[index + 1] as string
     index++
-  } else {
+  }
+  else {
     options[key as string] = true
   }
   return index
@@ -56,16 +61,19 @@ function parseShortOption(
   const [key, value] = arg.slice(1).split('=')
 
   // Check if key is undefined and handle it
-  if (key === undefined) return index
+  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 {
+  }
+  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 {
+      }
+      else {
         options[key[j] as string] = true
       }
     }
@@ -75,16 +83,20 @@ function parseShortOption(
 }
 
 export function parseArgv(argv?: string[]): ParsedArgv {
-  if (argv === undefined) argv = process.argv.slice(2)
+  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)
+    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)
   }
 
@@ -92,7 +104,8 @@ export function parseArgv(argv?: string[]): ParsedArgv {
 }
 
 export function parseArgs(argv?: string[]): string[] {
-  if (argv === undefined) argv = process.argv.slice(2)
+  if (argv === undefined)
+    argv = process.argv.slice(2)
 
   return parseArgv(argv).args
 }
@@ -106,6 +119,7 @@ interface CliOptions {
 
 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++) {
@@ -114,57 +128,55 @@ export function parseOptions(options?: CliOptions): CliOptions {
       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
+        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 (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 {
+        }
+        else {
           options[camelCaseKey] = args[i + 1]
           i++
         }
-      } else {
+      }
+      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 (Object.keys(options).length === 0)
+    // if options has no keys, return an empty object
+    return {}
 
-    if (value === 'true' || value === 'false') options[key] = value === 'true'
-  })
-
-  return options
+  return { ...defaults, ...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()
+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 (options?.verbose) {
-    log.debug('process.argv', process.argv)
-    log.debug('process.argv.slice(2)', process.argv.slice(2))
-    log.debug('options inside buddyOptions', options)
+  if (typeof options === 'object' && options !== null) {
+    return Object.entries(options)
+      .map(([key, value]) => {
+        if (value === true)
+          return `--${key}`
+        return `--${key} ${value}`
+      })
+      .join(' ')
   }
 
-  return options.join(' ')
+  return buddyOptions(process.argv.slice(2))
 }

package/src/run.ts

@@ -1,5 +1,6 @@
-import type { Result } from '@stacksjs/error-handling'
-import type { CliOptions, CommandError, Subprocess } from '@stacksjs/types'
+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'
@@ -90,7 +91,10 @@ export async function runCommandSync(command: string, options?: CliOptions): Pro
  * @param options The options to pass to the command.
  * @returns The result of the command.
  */
-export async function runCommands(commands: string[], options?: CliOptions) {
+export async function runCommands(
+  commands: string[],
+  options?: CliOptions,
+): Promise<Ok<Subprocess<Writable, Readable, Readable>, Error>[]> {
   const results = []
 
   for (const command of commands) {

package/src/spinner.ts

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

package/src/utils.ts

@@ -1,20 +1,21 @@
-import { collect } from '@stacksjs/collections'
-
-export * as kolorist from 'kolorist'
+import { collect, type Collection } from '@stacksjs/collections'
 
 export {
-  stripAnsi,
-  centerAlign,
-  rightAlign,
-  leftAlign,
   align,
   box,
+  centerAlign,
+  colorize,
   colors,
   getColor,
-  colorize,
+  leftAlign,
+  rightAlign,
+  stripAnsi,
 } from 'consola/utils'
 
+export * as kolorist from 'kolorist'
+
 export {
+  ansi256,
   ansi256Bg,
   bgBlack,
   bgBlue,
@@ -54,16 +55,15 @@ export {
   red,
   reset,
   strikethrough,
+  stripColors,
+  trueColor,
+  trueColorBg,
   underline,
   white,
   yellow,
-  ansi256,
-  trueColor,
-  trueColorBg,
-  stripColors,
 } from 'kolorist'
 
-export const quotes = collect([
+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.',