Struct Cli 

pub struct Cli {
    pub command: Commands,
    pub root: Option<PathBuf>,
    pub log_level: LogLevel,
    pub format: OutputFormatArg,
    pub no_color: bool,
    pub config: Option<PathBuf>,
    pub quiet: bool,
    pub verbose: bool,
}

Workspace Tools - Changeset-based version management.

This CLI provides comprehensive tools for managing Node.js workspaces using a changeset-based workflow. It supports both single-package and monorepo projects with independent or unified versioning strategies.

Global Options

All global options apply to ALL subcommands and control behavior across the entire application:

• --root: Changes working directory before executing commands
• --log-level: Controls logging verbosity (stderr only)
• --format: Controls output format (stdout only)
• --no-color: Disables ANSI colors in output and logs
• --config: Override default config file location

Stream Separation

The CLI maintains strict separation between:

• stderr: Logs only (controlled by --log-level)
• stdout: Command output only (controlled by --format)

This ensures JSON output is never contaminated with logs, enabling reliable piping and parsing in scripts.

Examples

# Initialize a new project
workspace init

# Add a changeset
workspace changeset add

# Preview version bump
workspace bump --dry-run

# JSON output with no logs (clean JSON for automation)
workspace --format json --log-level silent bump --dry-run

# Debug logging with text output
workspace --log-level debug changeset list

Fields

command: Commands

Subcommand to execute.

root: Option<PathBuf>

Project root directory.

Changes working directory before executing the command. All file operations will be relative to this path.

Default: Current directory

log_level: LogLevel

Logging level.

Controls verbosity of operation logs written to stderr. Does NOT affect command output (stdout).

Levels:

• silent: No logs at all
• error: Only critical errors
• warn: Errors + warnings
• info: General progress (default)
• debug: Detailed operations
• trace: Very verbose debugging

Default: info

format: OutputFormatArg

Output format.

Controls format of command output written to stdout. Does NOT affect logging (stderr).

Formats:

• human: Human-readable with colors and tables (default)
• json: Pretty-printed JSON
• json-compact: Compact JSON (single line)
• quiet: Minimal output

Default: human

no_color: bool

Disable colored output.

Removes ANSI color codes from both logs (stderr) and output (stdout). Also respects the NO_COLOR environment variable.

Useful for CI/CD environments and file redirection.

config: Option<PathBuf>

Path to config file.

Override default config file location. Path can be relative or absolute.

Default: Auto-detect (.changesets.{toml,json,yaml,yml})

quiet: bool

Quiet mode.

Minimizes both logs (stderr) and output (stdout). Equivalent to --log-level silent --format quiet.

Useful for scripts and automation where only exit code matters. Cannot be combined with –log-level, –format, or –verbose.

verbose: bool

Verbose output mode.

Increases detail level in command output (stdout) and enables debug logs (stderr). Equivalent to --log-level debug.

Different from –log-level which only controls operational logs. Cannot be combined with –log-level or –quiet.

Implementations

impl Cli

pub const fn log_level(&self) -> LogLevel

Returns the raw log level from command line.

Note: Prefer effective_log_level() which accounts for –quiet and –verbose flags.

Examples

use clap::Parser;
use sublime_cli_tools::cli::{Cli, LogLevel};

let cli = Cli::parse_from(["workspace", "--log-level", "debug", "version"]);
assert_eq!(cli.log_level(), LogLevel::Debug);

pub const fn effective_log_level(&self) -> LogLevel

Returns the effective log level, accounting for –quiet and –verbose flags.

Priority:

1. –quiet: Returns Silent
2. –verbose: Returns Debug
3. Otherwise: Returns the value from –log-level

Examples

use clap::Parser;
use sublime_cli_tools::cli::{Cli, LogLevel};

// --quiet overrides to silent
let cli = Cli::parse_from(["workspace", "--quiet", "version"]);
assert_eq!(cli.effective_log_level(), LogLevel::Silent);

// --verbose sets debug level
let cli = Cli::parse_from(["workspace", "--verbose", "version"]);
assert_eq!(cli.effective_log_level(), LogLevel::Debug);

// Default uses --log-level value
let cli = Cli::parse_from(["workspace", "--log-level", "warn", "version"]);
assert_eq!(cli.effective_log_level(), LogLevel::Warn);

pub const fn output_format(&self) -> OutputFormat

Returns the raw output format from command line.

Note: Prefer effective_output_format() which accounts for –quiet flag.

Examples

use clap::Parser;
use sublime_cli_tools::cli::Cli;
use sublime_cli_tools::output::OutputFormat;

let cli = Cli::parse_from(["workspace", "--format", "json", "version"]);
assert_eq!(cli.output_format(), OutputFormat::Json);

pub const fn effective_output_format(&self) -> OutputFormat

Returns the effective output format, accounting for –quiet flag.

Priority:

1. –quiet: Returns Quiet
2. Otherwise: Returns the value from –format

Examples

use clap::Parser;
use sublime_cli_tools::cli::Cli;
use sublime_cli_tools::output::OutputFormat;

// --quiet overrides to quiet format
let cli = Cli::parse_from(["workspace", "--quiet", "version"]);
assert_eq!(cli.effective_output_format(), OutputFormat::Quiet);

// Default uses --format value
let cli = Cli::parse_from(["workspace", "--format", "json", "version"]);
assert_eq!(cli.effective_output_format(), OutputFormat::Json);

pub fn is_color_disabled(&self) -> bool

Returns whether color output is disabled.

Also checks the NO_COLOR environment variable.

Examples

use clap::Parser;
use sublime_cli_tools::cli::Cli;

let cli = Cli::parse_from(["workspace", "--no-color", "version"]);
assert!(cli.is_color_disabled());

pub const fn root(&self) -> Option<&PathBuf>

Returns the root directory.

Examples

use clap::Parser;
use sublime_cli_tools::cli::Cli;
use std::path::PathBuf;

let cli = Cli::parse_from(["workspace", "--root", "/tmp", "version"]);
assert_eq!(cli.root(), Some(&PathBuf::from("/tmp")));

pub const fn config_path(&self) -> Option<&PathBuf>

Returns the config file path.

Examples

use clap::Parser;
use sublime_cli_tools::cli::Cli;
use std::path::PathBuf;

let cli = Cli::parse_from(["workspace", "--config", "custom.toml", "version"]);
assert_eq!(cli.config_path(), Some(&PathBuf::from("custom.toml")));

Trait Implementations

impl Args for Cli

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl CommandFactory for Cli

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Cli

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Cli

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Cli

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.