Class ListCommand

The list command is used to view a list of commands

Example

// Usage from CLI: node ace list
// Or with namespace filter: node ace list migrate
// Or as JSON: node ace list --json
const listCommand = new ListCommand(kernel, parsed, ui, prompt)
await listCommand.run()

Hierarchy (View Summary)

BaseCommand
- ListCommand

Index

Constructors

constructor

new ListCommand(
    kernel: Kernel<any>,
    parsed: ParsedOutput,
    ui: {},
    prompt: Prompt,
): ListCommand
Create a new base command instance
Parameters
- kernel: Kernel<any>
  The Ace kernel instance
- parsed: ParsedOutput
  The parsed CLI input
- ui: {}
  UI primitives for output
- prompt: Prompt
  Prompt utilities for user interaction
Returns ListCommand
Inherited from BaseCommand.constructor
- Defined in src/commands/base.ts:527

Properties

`Static`booted

booted: boolean = false

Whether the command class has been booted

`Static`options

options: CommandOptions

Configuration options accepted by the command

`Static`aliases

aliases: string[]

A collection of aliases for the command

`Static`args

args: Argument[]

Registered arguments

`Static`flags

flags: Flag[]

Registered flags

`Optional`exitCode

exitCode?: number

The exit code for the command

`Optional`error

error?: any

The error raised at the time of executing the command. The value is undefined if no error is raised.

`Optional`result

result?: any

The result property stores the return value of the "run" method (unless command sets it explicitly)

ui

ui: {}

UI primitives for output

prompt

prompt: Prompt

Prompt utilities for user interaction

`Static`commandName

commandName: string = 'list'

Command metadata

`Static`description

description: string = 'View list of available commands'

The command description

`Static`help

help: string[] = ...

The help text for the command. Help text can be a multiline string explaining the usage of command

`Optional`namespaces

namespaces?: string[]

Optional namespaces to filter the command list

`Optional`json

json?: boolean

Flag to output the command list as JSON

Accessors

logger

get logger(): Logger
Logger to log messages

Returns Logger
Example
```
this.logger.info('Command executed successfully')
this.logger.error('Something went wrong')
```
Inherited from BaseCommand.logger
- Defined in src/commands/base.ts:460

colors

get colors(): Colors
Add colors to console messages

Returns Colors
Example
```
this.logger.info(this.colors.green('Success!'))
this.logger.error(this.colors.red('Error!'))
```
Inherited from BaseCommand.colors
- Defined in src/commands/base.ts:473

isMain

get isMain(): boolean
Is the current command the main command executed from the CLI

Returns boolean
Example
```
if (this.isMain) {
  this.logger.info('This is the main command')
}
```
Inherited from BaseCommand.isMain
- Defined in src/commands/base.ts:487

commandName

get commandName(): string
Reference to the command name

Returns string
Inherited from BaseCommand.commandName
- Defined in src/commands/base.ts:494

options

get options(): CommandOptions
Reference to the command options

Returns CommandOptions
Inherited from BaseCommand.options
- Defined in src/commands/base.ts:501

args

get args(): Argument[]
Reference to the command args

Returns Argument[]
Inherited from BaseCommand.args
- Defined in src/commands/base.ts:508

flags

get flags(): Flag[]
Reference to the command flags

Returns Flag[]
Inherited from BaseCommand.flags
- Defined in src/commands/base.ts:515

Methods

`Static`boot

boot(): void
Define static properties on the class. During inheritance, certain properties must inherit from the parent.

Returns void
Example
```
MyCommand.boot()
```
Inherited from BaseCommand.boot
- Defined in src/commands/base.ts:101

`Static`defineArgument

defineArgument(
name: string,
options: Partial<Argument> & { type: "string" | "spread" },
): void
Specify the argument the command accepts. The arguments via the CLI will be accepted in the same order as they are defined.

Mostly, you will be using the @args decorator to define the arguments.
Parameters
- name: string
  The name of the argument
- options: Partial<Argument> & { type: "string" | "spread" }
  Configuration options for the argument
Returns void
Example
```
Command.defineArgument('entity', { type: 'string' })
Command.defineArgument('files', { type: 'spread', required: false })
```
Inherited from BaseCommand.defineArgument
- Defined in src/commands/base.ts:134

`Static`defineFlag

defineFlag(
    name: string,
    options: Partial<Flag> & {
        type: "string" | "number" | "boolean" | "array";
    },
): void
Specify a flag the command accepts.

Mostly, you will be using the @flags decorator to define a flag.
Parameters
- name: string
  The name of the flag
- options: Partial<Flag> & { type: "string" | "number" | "boolean" | "array" }
  Configuration options for the flag
Returns void
Example
```
Command.defineFlag('connection', { type: 'string', required: true })
Command.defineFlag('force', { type: 'boolean' })
Command.defineFlag('tags', { type: 'array' })
```
Inherited from BaseCommand.defineFlag
- Defined in src/commands/base.ts:189

`Static`getParserOptions

getParserOptions(
    options?: FlagsParserOptions,
): {
    flagsParserOptions: Required<FlagsParserOptions>;
    argumentsParserOptions: ArgumentsParserOptions[];
}
Returns the options for parsing flags and arguments
Parameters
- Optionaloptions: FlagsParserOptions
  Optional parser options to merge
Returns {
flagsParserOptions: Required<FlagsParserOptions>;
argumentsParserOptions: ArgumentsParserOptions[];
}
Inherited from BaseCommand.getParserOptions
- Defined in src/commands/base.ts:217

`Static`serialize

serialize(): CommandMetaData
Serializes the command to JSON. The return value satisfies the CommandMetaData

Returns CommandMetaData
Example
```
const metadata = MyCommand.serialize()
console.log(metadata.commandName) // 'my:command'
```
Inherited from BaseCommand.serialize
- Defined in src/commands/base.ts:291

`Static`validate

validate(parsedOutput: ParsedOutput): void
Validate the yargs parsed output against the command.
Parameters
- parsedOutput: ParsedOutput
  The parsed CLI input to validate
Returns void
Example
```
const parsed = { args: ['value'], flags: { force: true }, unknownFlags: [] }
MyCommand.validate(parsed)
```
Inherited from BaseCommand.validate
- Defined in src/commands/base.ts:328

hydrate

hydrate(): void
Hydrate command by setting class properties from the parsed output

Returns void
Example
```
command.hydrate()
console.log(command.name) // Argument value
console.log(command.force) // Flag value
```
Inherited from BaseCommand.hydrate
- Defined in src/commands/base.ts:546

exec

exec(): Promise<any>
Executes the command by running the command's run method.

Returns Promise<any>
Example
```
const result = await command.exec()
console.log('Exit code:', command.exitCode)
```
Inherited from BaseCommand.exec
- Defined in src/commands/base.ts:604

toJSON

toJSON(): {
    commandName: string;
    options: CommandOptions;
    args: any[];
    flags: { [argName: string]: any };
    error: any;
    result: any;
    exitCode: undefined | number;
}
JSON representation of the command

Returns {
    commandName: string;
    options: CommandOptions;
    args: any[];
    flags: { [argName: string]: any };
    error: any;
    result: any;
    exitCode: undefined | number;
}
Example
```
const json = command.toJSON()
console.log(json.commandName, json.exitCode)
```
Inherited from BaseCommand.toJSON
- Defined in src/commands/base.ts:627

assertExitCode

assertExitCode(code: number): void
Assert the command exits with a given exit code
Parameters
- code: number
  The expected exit code
Returns void
Example
```
command.assertExitCode(0) // Assert successful execution
command.assertExitCode(1) // Assert failure
```
Inherited from BaseCommand.assertExitCode
- Defined in src/commands/base.ts:650

assertNotExitCode

assertNotExitCode(code: number): void
Assert the command does not exit with a given exit code
Parameters
- code: number
  The exit code that should not be used
Returns void
Example
```
command.assertNotExitCode(1) // Assert no failure
```
Inherited from BaseCommand.assertNotExitCode
- Defined in src/commands/base.ts:672

assertSucceeded

assertSucceeded(): void
Assert the command exits with zero exit code

Returns void
Example
```
command.assertSucceeded() // Assert success
```
Inherited from BaseCommand.assertSucceeded
- Defined in src/commands/base.ts:689

assertFailed

assertFailed(): void
Assert the command exits with non-zero exit code

Returns void
Example
```
command.assertFailed() // Assert failure
```
Inherited from BaseCommand.assertFailed
- Defined in src/commands/base.ts:701

assertLog

assertLog(message: string, stream?: "stdout" | "stderr"): void
Assert command logs the expected message
Parameters
- message: string
  The expected log message
- Optionalstream: "stdout" | "stderr"
  Optional stream to check ('stdout' or 'stderr')
Returns void
Example
```
command.assertLog('Command executed successfully')
command.assertLog('Error occurred', 'stderr')
```
Inherited from BaseCommand.assertLog
- Defined in src/commands/base.ts:717

assertLogMatches

assertLogMatches(matchingRegex: RegExp, stream?: "stdout" | "stderr"): void
Assert command logs a message matching the given regex
Parameters
- matchingRegex: RegExp
  The regex pattern to match against log messages
- Optionalstream: "stdout" | "stderr"
  Optional stream to check ('stdout' or 'stderr')
Returns void
Example
```
command.assertLogMatches(/^Command.*completed$/)
command.assertLogMatches(/error/i, 'stderr')
```
Inherited from BaseCommand.assertLogMatches
- Defined in src/commands/base.ts:763

assertTableRows

assertTableRows(rows: string[][]): void
Assert the command prints a table with the expected rows to stdout
Parameters
- rows: string[][]
  The expected table rows as arrays of strings
Returns void
Example
```
command.assertTableRows([
  ['Name', 'Age'],
  ['John', '25'],
  ['Jane', '30']
])
```
Inherited from BaseCommand.assertTableRows
- Defined in src/commands/base.ts:807

run

run(): Promise<void>
Executes the list command to display available commands

Returns Promise<void>
Example
```
await listCommand.run()
```
Overrides BaseCommand.run
- Defined in src/commands/list.ts:201

Class ListCommand

Example

Hierarchy (View Summary)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns ListCommand

Properties

Staticbooted

Staticoptions

Staticaliases

Staticargs

Staticflags

OptionalexitCode

Optionalerror

Optionalresult

ui

prompt

StaticcommandName

Staticdescription

Statichelp

Optionalnamespaces

Optionaljson

Accessors

logger

Returns Logger

Example

colors

Returns Colors

Example

isMain

Returns boolean

Example

commandName

Returns string

options

Returns CommandOptions

args

Returns Argument[]

flags

Returns Flag[]

Methods

Staticboot

Returns void

Example

StaticdefineArgument

Parameters

Returns void

Example

StaticdefineFlag

Parameters

Returns void

Example

StaticgetParserOptions

Parameters

Returns { flagsParserOptions: Required<FlagsParserOptions>; argumentsParserOptions: ArgumentsParserOptions[];}

Staticserialize

Returns CommandMetaData

Example

Staticvalidate

Parameters

Returns void

Example

hydrate

Returns void

Example

exec

Returns Promise<any>

Example

toJSON

Returns { commandName: string; options: CommandOptions; args: any[]; flags: { [argName: string]: any }; error: any; result: any; exitCode: undefined | number;}

Example

assertExitCode

Parameters

Returns void

`Static`booted

`Static`options

`Static`aliases

`Static`args

`Static`flags

`Optional`exitCode

`Optional`error

`Optional`result

`Static`commandName

`Static`description

`Static`help

`Optional`namespaces

`Optional`json

`Static`boot

`Static`defineArgument

`Static`defineFlag

`Static`getParserOptions

Returns {
flagsParserOptions: Required<FlagsParserOptions>;
argumentsParserOptions: ArgumentsParserOptions[];
}

`Static`serialize

`Static`validate

Returns {
commandName: string;
options: CommandOptions;
args: any[];
flags: { [argName: string]: any };
error: any;
result: any;
exitCode: undefined | number;
}