Cookie Consent by TIBET


Command Tools

Command Tools (Overview)


  • Simplify tasks from app creation to testing, building, and deploying.
  • Leverage shared application and library metadata for smarter operation.
  • Fully integrated with the TIBET Desktop and TIBET Data Server (TDS).
  • Easily extended via custom command plugins and/or tibet make targets.
  • Document your application specifics using built-in manpage generation.


With any development process there are numerous admin tasks to perform.

You need to create your application, build it, test it, and deploy it iteratively.

A consistent, well-maintained toolchain is key to staying productive.

TIBET supplies a complete toolchain via the tibet command.

tibet help
tibet help

tibet commands vs. tibet make targets

The tibet command relies on two forms of command implementation: commands and tibet make targets.

A command is a subtype of TIBET's root _cmd parent type which implements an execute method. Commands are found in the ~app_cmd directory.

A tibet make target is a function which takes a handle to the make object along with a Promise resolver and rejector used to signify completion.

The combination of OO and function-based extension mechanisms means you can expand your application's command line capabilities in whatever way best suits your requirements.

When you invoke tibet <command|target> TIBET will first search for a command and will then delegate to tibet make to search for a matching target.

tibet build
Delegating to 'tibet make build'

Most TIBET-specific operations are implemented as commands, while most app-specific operations have pre-built tibet make target functions.

This approach makes it easier for you to customize the TIBET CLI to meet your specific project requirements.

Metadata Driven

Unlike a typical task runner, the tibet command and its various subcommands and tibet make targets have access to your application's runtime information from configuration data to the types, methods, and resources your application uses.

By accessing shared configuration, metadata, and runtime information the individual commands work collectively and intelligently to optimize their operation for your particular application.

TIBET's use of metadata for command line enhancement can be seen in how it handles linting, testing, documenting, and packaging your code among others.

App vs. Lib

Like much of TIBET, the tibet command relies on a foundation of library commands and tibet make targets, but overlays commands and targets found in your application directory structure.

With TIBET you can replace a command or make target with your own variation, or simply add new commands and targets.

Writing documentation for the commands and targets you create is as simple as placing properly formatted markdown in the ~app_doc directory. (See TIBET Manpages for more info).

Help-Related Commands

tibet help

The tibet command used alone or with the --help or help form provide you a full list of TIBET's built-in commands along with any tibet make targets (similar to Grunt or Gulp tasks) you may have created for your project:

The tibet command provides a fully-supported set of commands to perform all the common tasks involved in creating, testing, packaging, and deploying applications.

tibet help
tibet help

tibet apropos

The TIBET CLI also helps you learn, develop, and onboard developers more quickly.

Say you need to know what operations are available relative to element visibility. The tibet apropos command loads both TIBET and your application and reflects on their code and comments, providing you a list of possible options.

Output from tibet apropos can be provided to tibet reflect to learn more:

tibet apropos
tibet apropos

With the TIBET CLI you're using a fully-supported, fully-integrated, fully-extensible power tool, one that understands both TIBET and your application code.

If you require functionality that isn't supported by the tibet command you can extend it using tibet make targets or custom TIBET commands.

tibet reflect

The tibet reflect command loads your application and produces information from the TIBET OO subsystem's reflection APIs. tibet reflect also reports on your application code, allowing you to reflect on your application's types, methods, and documentation just as easily:

tibet reflect
tibet reflect


For specific CLI recipes see the CLI Cookbook.


For help documenting your extensions see TIBET Manpages.