@stacksjs/cli 0.58.73 → 0.59.1

package/dist/actions/index.d.ts

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

package/dist/actions/install.d.ts

@@ -0,0 +1,27 @@
+import type { ExecaReturnValue } from 'execa';
+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 declare function installPackage(name: string, options?: InstallPackageOptions): Promise<ExecaReturnValue<string>>;
+/**
+ * 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 declare function installStack(name: string, options?: InstallPackageOptions): Promise<ExecaReturnValue<string>>;
+export {};

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+import { CAC } from 'cac';
+export interface ParsedArgv {
+    args: ReadonlyArray<string>;
+    options: {
+        [k: string]: any;
+    };
+}
+interface CliOptions {
+    name?: string;
+}
+export declare function cli(name?: string | CliOptions, options?: CliOptions): CAC;
+export { CAC };

package/dist/command.d.ts

@@ -0,0 +1,33 @@
+import type { CliOptions } from '@stacksjs/types';
+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 declare 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);
+}
+export declare const command: {
+    run: (command: string, options?: any) => Promise<Result<Subprocess, CommandError>>;
+    runSync: (command: string, options?: any) => Promise<Result<Subprocess, CommandError>>;
+};
+export {};

package/dist/console.d.ts

@@ -0,0 +1,18 @@
+import { log, logger } from '@stacksjs/logging';
+import prompts from 'prompts';
+export declare class Prompt {
+    private required;
+    constructor();
+    require(): this;
+    isRequired(): boolean;
+    select(message: any, options: any): Promise<any>;
+    checkbox(message: any, options: any): Promise<any>;
+    confirm(message: any, options: any): Promise<any>;
+    input(message: any, options: any): Promise<any>;
+    password(message: any, options: any): Promise<any>;
+    number(message: any, options: any): Promise<any>;
+    multiselect(message: any, options: any): Promise<any>;
+    autocomplete(message: any, options: any): Promise<any>;
+}
+export { prompts, logger, log };
+export declare const prompt: () => Prompt;

package/dist/exec.d.ts

@@ -0,0 +1,40 @@
+import { type Result } from '@stacksjs/error-handling';
+import type { CliOptions, Subprocess } 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 declare function exec(command: string | string[], options?: CliOptions): Promise<Result<Subprocess, Error>>;
+/**
+ * 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 declare function execSync(command: string | string[], options?: CliOptions): Promise<string>;

package/dist/helpers.d.ts

@@ -0,0 +1,9 @@
+import type { IntroOptions, OutroOptions } from '@stacksjs/types';
+/**
+ * Prints the intro message.
+ */
+export declare function intro(command: string, options?: IntroOptions): Promise<number>;
+/**
+ * Prints the outro message.
+ */
+export declare function outro(text: string, options?: OutroOptions, error?: Error | string): Promise<unknown>;

package/dist/index.d.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 './utils';

package/dist/index.js

@@ -54,8 +54,8 @@ async function exec(command, options) {
   return err(handleError(`Failed to execute command: ${cmd.join(" ")}`));
 }
 async function execSync(command, options) {
-  log2.debug("Running execSync:", command);
-  log2.debug("execSync Options:", options);
+  log2.debug("Running ExecSync:", command);
+  log2.debug("ExecSync Options:", options);
   const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]+|"[^"]*")+/g);
   if (!cmd) {
     log2.error(`Failed to parse command: ${cmd}`, options);
@@ -520,7 +520,7 @@ import {log as log3} from "@stacksjs/logging";
 import {ExitCode as ExitCode2} from "@stacksjs/types";
 import {bgCyan as bgCyan2, bold as bold2, cyan as cyan2, dim as dim2, gray as gray2, green as green2, italic as italic2} from "kolorist";
 // package.json
-var version = "0.58.73";
+var version = "0.59.1";
 
 // src/helpers.ts
 async function intro(command2, options) {

package/dist/parse.d.ts

@@ -0,0 +1,17 @@
+interface ParsedArgv {
+    args: string[];
+    options: {
+        [k: string]: string | boolean | number;
+    };
+}
+export declare function parseArgv(argv?: string[]): ParsedArgv;
+export declare function parseArgs(argv?: string[]): string[];
+interface CliOptions {
+    dryRun?: boolean;
+    quiet?: boolean;
+    verbose?: boolean;
+    [k: string]: string | boolean | number | undefined;
+}
+export declare function parseOptions(options?: CliOptions): CliOptions;
+export declare function buddyOptions(options?: any): string;
+export {};

package/dist/run.d.ts

@@ -0,0 +1,63 @@
+import type { CliOptions, CommandError, Subprocess } from '@stacksjs/types';
+import type { Result } from '@stacksjs/error-handling';
+/**
+ * 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 declare function runCommand(command: string, options?: CliOptions): Promise<Result<Subprocess, CommandError>>;
+export declare function runProcess(command: string, options?: CliOptions): Promise<Result<Subprocess, CommandError>>;
+/**
+ * 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 declare function runCommandSync(command: string, options?: CliOptions): Promise<string>;
+/**
+ * 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 declare function runCommands(commands: string[], options?: CliOptions): Promise<any[]>;

package/dist/spinner.d.ts

@@ -0,0 +1,2 @@
+import ora from 'ora';
+export declare const spinner: typeof ora;

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+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 declare const quotes: any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/cli",
   "type": "module",
-  "version": "0.58.73",
+  "version": "0.59.1",
   "description": "TypeScript framework for CLI artisans. Build beautiful console apps with ease.",
   "author": "Chris Breuer",
   "license": "MIT",

package/src/exec.ts

@@ -84,8 +84,8 @@ export async function exec(command: string | string[], options?: CliOptions): Pr
  * ```
  */
 export async function execSync(command: string | string[], options?: CliOptions): Promise<string> {
-  log.debug('Running execSync:', command)
-  log.debug('execSync Options:', options)
+  log.debug('Running ExecSync:', command)
+  log.debug('ExecSync Options:', options)
 
   const cmd = Array.isArray(command)
     ? command