@stacksjs/cli 0.58.47 → 0.58.49

package/dist/index.js

@@ -14,7 +14,7 @@ async function installStack(name, options) {
 // src/cli.ts
 import cac from "cac";
 // package.json
-var version = "0.58.47";
+var version = "0.58.49";
 
 // src/cli.ts
 function cli(name, options) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/cli",
   "type": "module",
-  "version": "0.58.47",
+  "version": "0.58.49",
   "description": "TypeScript framework for CLI artisans. Build beautiful console apps with ease.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -48,7 +48,8 @@
   ],
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun --bun build.ts",
@@ -57,13 +58,13 @@
   },
   "peerDependencies": {
     "@antfu/install-pkg": "^0.3.1",
-    "@stacksjs/config": "workspace:*",
-    "@stacksjs/error-handling": "workspace:*",
-    "@stacksjs/logging": "workspace:*",
-    "@stacksjs/path": "workspace:*",
-    "@stacksjs/types": "workspace:*",
-    "@stacksjs/utils": "workspace:*",
-    "@stacksjs/validation": "workspace:*",
+    "@stacksjs/config": "latest",
+    "@stacksjs/error-handling": "latest",
+    "@stacksjs/logging": "latest",
+    "@stacksjs/path": "latest",
+    "@stacksjs/types": "latest",
+    "@stacksjs/utils": "latest",
+    "@stacksjs/validation": "latest",
     "@types/prompts": "^2.4.9",
     "cac": "^6.7.14",
     "ora": "^8.0.1",
@@ -85,6 +86,6 @@
     "prompts": "^2.4.2"
   },
   "devDependencies": {
-    "@stacksjs/development": "workspace:*"
+    "@stacksjs/development": "latest"
   }
 }

package/src/actions/index.ts

@@ -0,0 +1 @@
+export * from './install'

package/src/actions/install.ts

@@ -0,0 +1,40 @@
+import type { ExecaReturnValue } from 'execa'
+import { installPackage as installPkg } from '@antfu/install-pkg'
+
+interface InstallPackageOptions {
+  cwd?: string
+  dev?: boolean
+  silent?: boolean
+  packageManager?: string
+  packageManagerVersion?: string
+  preferOffline?: boolean
+  additionalArgs?: string[]
+}
+
+/**
+ * Install an npm package.
+ *
+ * @param name - The package name to install.
+ * @param options - The options to pass to the install.The options to pass to the install.
+ * @returns The result of the install.
+ */
+export async function installPackage(name: string, options?: InstallPackageOptions): Promise<ExecaReturnValue<string>> {
+  if (options)
+    return await installPkg(name, options)
+
+  return await installPkg(name, { silent: true })
+}
+
+/**
+ * Install a Stack into your project.
+ *
+ * @param name - The Stack name to install.
+ * @param options - The options to pass to the install.
+ * @returns The result of the install.
+ */
+export async function installStack(name: string, options?: InstallPackageOptions) {
+  if (options)
+    return await installPkg(`@stacksjs/${name}`, options)
+
+  return await installPkg(`@stacksjs/${name}`, { silent: true })
+}

package/src/cli.ts

@@ -0,0 +1,52 @@
+// import type { CliOptions } from '@stacksjs/types'
+import cac from 'cac'
+import { version } from '../package.json'
+
+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
+  }
+
+  const cli = cac(name)
+
+  cli.help()
+  cli.version(options?.version || version)
+
+  return cli
+}
+
+export function command(name: string, description: string, options?: CliOptions) {
+  return cli(options).command(name, description)
+}
+
+export function parseArgs() {
+  return cli().parse().args
+}
+
+export function parseOptions(): ParsedArgv['options'] {
+  const options = cli().parse().options
+
+  // Iterate over the options and convert "true" and "false" strings to boolean
+  for (const key in options) {
+    if (options[key] === 'true')
+      options[key] = true
+    else if (options[key] === 'false')
+      options[key] = false
+  }
+
+  return options
+}

package/src/command.ts

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,79 @@
+import { log } from '@stacksjs/logging'
+import prompts from 'prompts'
+
+export class Prompt {
+  private required: boolean
+
+  constructor() {
+    this.required = false
+  }
+
+  require() {
+    this.required = true
+    return this
+  }
+
+  isRequired() {
+    return this.required
+  }
+
+  async select(message: any, options: any) {
+    if (this.isRequired())
+      return log.prompt(message, { ...options, type: 'select', required: true })
+
+    return log.prompt(message, { ...options, type: 'select' })
+  }
+
+  async checkbox(message: any, options: any) {
+    if (this.isRequired())
+      return log.prompt(message, { ...options, type: 'multiselect', required: true })
+
+    return log.prompt(message, { ...options, type: 'multiselect' })
+  }
+
+  async confirm(message: any, options: any) {
+    if (this.isRequired())
+      return log.prompt(message, { ...options, type: 'confirm', required: true })
+
+    return log.prompt(message, { ...options, type: 'confirm' })
+  }
+
+  async input(message: any, options: any) {
+    if (this.isRequired())
+      return log.prompt(message, { ...options, type: 'text', required: true })
+
+    return log.prompt(message, { ...options, type: 'text' })
+  }
+
+  async password(message: any, options: any) {
+    if (this.isRequired())
+      return log.prompt(message, { ...options, type: 'password', required: true })
+
+    return log.prompt(message, { ...options, type: 'password' })
+  }
+
+  async number(message: any, options: any) {
+    if (this.isRequired())
+      return log.prompt(message, { ...options, type: 'numeral', required: true })
+
+    return log.prompt(message, { ...options, type: 'numeral' })
+  }
+
+  async multiselect(message: any, options: any) {
+    if (this.isRequired())
+      return log.prompt(message, { ...options, type: 'multiselect', required: true })
+
+    return log.prompt(message, { ...options, type: 'multiselect' })
+  }
+
+  async autocomplete(message: any, options: any) {
+    if (this.isRequired())
+      return log.prompt(message, { ...options, type: 'autocomplete', required: true })
+
+    return log.prompt(message, { ...options, type: 'autocomplete' })
+  }
+}
+
+export { prompts, log }
+
+export const prompt = new Prompt()

package/src/exec.ts

@@ -0,0 +1,89 @@
+import process from 'node:process'
+import { type Result, err, handleError, ok } from '@stacksjs/error-handling'
+import type { CliOptions, StacksError, Subprocess } from '@stacksjs/types'
+import { ExitCode } from '@stacksjs/types'
+
+/**
+ * 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, StacksError>> {
+  const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]+|"[^"]*")+/g)
+
+  if (!cmd)
+    return err(handleError(`Failed to parse command: ${cmd}`, options))
+
+  if (options?.verbose)
+    // eslint-disable-next-line no-console
+    console.log('exec', { command, cmd, options })
+
+  const proc = Bun.spawn(cmd, {
+    ...options,
+    stdout: options?.silent ? 'ignore' : (options?.stdin ? options.stdin : (options?.stdout || 'inherit')),
+    stderr: options?.silent ? 'ignore' : (options?.stderr || 'inherit'),
+    detached: options?.background || false,
+    cwd: options?.cwd || import.meta.dir,
+    // env: { ...e, ...options?.env },
+    onExit(_subprocess, exitCode, _signalCode, _error) {
+      if (exitCode && exitCode !== ExitCode.Success)
+        process.exit(exitCode)
+    },
+  })
+
+  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> {
+  const cmd = Array.isArray(command) ? command : command.split(' ')
+  const proc = Bun.spawnSync(cmd, {
+    ...options,
+    // stdin: 'inherit',
+    stdout: options?.stdout ?? 'pipe',
+    stderr: options?.stderr ?? 'inherit',
+    cwd: options?.cwd ?? import.meta.dir,
+    // env: { ...Bun.env, ...options?.env },
+    onExit(_subprocess, exitCode, _signalCode, _error) {
+      // console.log('onExit', { subprocess, exitCode, signalCode, error })
+      if (exitCode !== ExitCode.Success && exitCode)
+        process.exit(exitCode)
+    },
+  })
+
+  return proc.stdout.toString()
+}

package/src/helpers.ts

@@ -0,0 +1,80 @@
+/* eslint-disable no-console */
+import { config } from '@stacksjs/config'
+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()
+    }
+
+    let msg = `Running  ${bgCyan(italic(bold(` ${command} `)))}`
+    if (command === 'buddy deploy')
+      msg = `Running  ${bgCyan(italic(bold(` ${command} `)))}  for ${bold(`${config.app.name}`)} ${italic(`via ${config.app.url}`)}`
+
+    log.info(msg)
+
+    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')
+        console.log(`${dim(gray(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}]`))} ${opts.message ?? 'Complete'}`)
+      else
+        console.log(`${dim(gray(bold(`[${time.toFixed(2)}${opts.useSeconds ? 's' : 'ms'}]`)))} ${bold(green(opts.message ?? 'Complete'))}`)
+    }
+
+    else {
+      if (opts?.type === 'info')
+        console.log(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

@@ -0,0 +1,10 @@
+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 './utilities'

package/src/parse.ts

@@ -0,0 +1,101 @@
+import process from 'node:process'
+
+interface ParsedArgv {
+  args: string[]
+  options: {
+    [k: string]: string | boolean | number
+  }
+}
+
+function isLongOption(arg: string): boolean {
+  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] = parseValue(value)
+  }
+  else if (index + 1 < argv.length && !argv[index + 1].startsWith('-')) {
+    options[key] = argv[index + 1]
+    index++
+  }
+  else {
+    options[key] = 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('=')
+
+  if (value !== undefined) {
+    for (let j = 0; j < key.length; j++)
+      options[key[j]] = 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]] = parseValue(argv[index + 1])
+        index++
+      }
+      else {
+        options[key[j]] = 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 (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 parseOptions(argv?: string[]): { [k: string]: string | boolean | number } {
+//   if (argv === undefined)
+//     argv = process.argv.slice(2)
+
+//   return parseArgv(argv).options
+// }
+
+export function parseArgs(argv?: string[]): string[] {
+  if (argv === undefined)
+    argv = process.argv.slice(2)
+
+  return parseArgv(argv).args
+}

package/src/run.ts

@@ -0,0 +1,99 @@
+import type { CliOptions, CommandError, Subprocess } from '@stacksjs/types'
+import type { Result } from '@stacksjs/error-handling'
+import { exec, execSync } from './exec'
+import { italic, underline } from './utilities'
+import { log } from './console'
+
+/**
+ * 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>> {
+  if (options?.verbose)
+    log.debug('Running command:', underline(italic(command)), 'with options:', options)
+
+  return await exec(command, options)
+}
+
+export async function runProcess(command: string, options?: CliOptions): Promise<Result<Subprocess, CommandError>> {
+  if (options?.verbose)
+    log.debug('Running command:', underline(italic(command)), 'with 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> {
+  if (options?.verbose)
+    log.debug('Running command:', underline(italic(command)), 'with 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)
+    results.push(await runCommand(command, options))
+
+  return results
+}

package/src/spinner.ts

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

package/src/utilities.ts

@@ -0,0 +1,2 @@
+export * as kolorist from 'kolorist'
+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'