Enum Command 

pub enum Command {
    Init {
        toml: bool,
        name: Option<String>,
        starter: Option<String>,
        start: bool,
    },
    New {
        directory: String,
        toml: bool,
        name: Option<String>,
        starter: Option<String>,
        start: bool,
    },
    Ext(ExtCommand),
    Patches(PatchesCommand),
    Add {
        packages: Vec<String>,
        dev: bool,
        with_dependencies: bool,
        with_all_dependencies: bool,
        no_sync: bool,
        frozen: bool,
        resolution: ResolutionStrategy,
        working_dir: Option<PathBuf>,
        dry_run: bool,
    },
    Remove {
        packages: Vec<String>,
        dev: bool,
        no_sync: bool,
        frozen: bool,
        working_dir: Option<PathBuf>,
        dry_run: bool,
    },
    Lock {
        resolution: ResolutionStrategy,
        working_dir: Option<PathBuf>,
        dry_run: bool,
    },
    Tree {
        package: Option<String>,
        no_dev: bool,
        working_dir: Option<PathBuf>,
    },
    Outdated {
        packages: Vec<String>,
        direct: bool,
        major_only: bool,
        minor_only: bool,
        patch_only: bool,
        no_dev: bool,
        strict: bool,
        working_dir: Option<PathBuf>,
    },
    Sync {
        offline: bool,
        dry_run: bool,
        scripts: bool,
        no_scripts: bool,
        resolution: ResolutionStrategy,
        patches: bool,
        no_patches: bool,
        php: PhpPrefArgs,
    },
    Run {
        with: Vec<String>,
        no_sync: bool,
        xdebug: bool,
        php_request: Option<String>,
        php: PhpPrefArgs,
        argv: Vec<String>,
    },
    Php(PhpCommand),
    Node(NodeCommand),
    Composer(ComposerCommand),
    Tool(ToolCommand),
    ToolExec {
        wrapper: PathBuf,
        args: Vec<OsString>,
    },
    Cache(CacheCommand),
    SelfCmd(SelfCommand),
    Server(ServerArgs),
    Services(ServicesCommand),
    Projects(ProjectsCommand),
    Start {
        no_sync: bool,
        dry_run: bool,
        explain: bool,
        no_builtin: bool,
        recipe: Option<String>,
    },
    Stop {
        names: Vec<String>,
        purge: bool,
    },
    Make {
        task: Option<String>,
        list: bool,
        dry_run: bool,
        explain: bool,
        no_sync: bool,
        no_builtin: bool,
        recipe: Option<String>,
        print: bool,
    },
    Format {
        args: Vec<OsString>,
    },
}

Variants

Init

Create a new project

Fields

toml: bool

Place bougie configuration in a bougie.toml file

name: Option<String>

Set the package name (vendor/package) of the generated composer.json. Overrides the name from a --starter manifest

starter: Option<String>

Scaffold from a starter pack: a built-in alias (e.g. mageos) or an https URL serving a starter manifest. Writes the starter’s composer.json instead of the empty default

start: bool

After scaffolding, bring the project up. Equivalent to bougie start

New

Create a new project in a new directory

Fields

directory: String

Directory to create under the current directory and scaffold the project into

toml: bool

Place bougie configuration in a bougie.toml file

name: Option<String>

Set the package name (vendor/package) of the generated composer.json. Overrides the name from a --starter manifest

starter: Option<String>

Scaffold from a starter pack: a built-in alias (e.g. mageos) or an https URL serving a starter manifest

start: bool

After scaffolding, bring the project up. Equivalent to bougie start

Ext(ExtCommand)

Manage PHP extensions

Patches(PatchesCommand)

Manage patches applied to installed packages

Add

Add dependencies to the project

Fields

packages: Vec<String>

Packages to add, vendor/pkg or vendor/pkg@<constraint>

dev: bool

Add to require-dev instead of require

with_dependencies: bool

Also update the new packages’ dependencies (-w)

with_all_dependencies: bool

Also update all dependencies, including shared ones (-W)

no_sync: bool

Update composer.json + composer.lock but don’t install into vendor/

frozen: bool

Edit composer.json only — don’t touch the lock or vendor/

resolution: ResolutionStrategy

Version-preference policy when resolving

working_dir: Option<PathBuf>

Run in this directory instead of CWD (-d)

dry_run: bool

Resolve and report what would change without writing anything

Remove

Remove dependencies from the project

Fields

packages: Vec<String>

Packages to remove (vendor/name)

dev: bool

Remove from require-dev instead of require

no_sync: bool

Re-resolve composer.lock but don’t touch vendor/

frozen: bool

Edit composer.json only — don’t touch the lock or vendor/

working_dir: Option<PathBuf>

Run in this directory instead of CWD (-d)

dry_run: bool

Resolve and report what would change without writing anything

Lock

Update the project’s lockfile

Fields

resolution: ResolutionStrategy

Version-preference policy when re-resolving changed requires

working_dir: Option<PathBuf>

Run in this directory instead of CWD (-d)

dry_run: bool

Resolve and report what would change without writing the lock

Tree

Display the project’s dependency tree

Fields

package: Option<String>

Root the tree at this package instead of the project

no_dev: bool

Skip dev dependencies

working_dir: Option<PathBuf>

Run in this directory instead of CWD (-d)

Outdated

List installed packages with newer versions available

Fields

packages: Vec<String>

Optional vendor/name filters; with none, all are considered

direct: bool

Only the project’s direct dependencies (--direct / -D)

major_only: bool

Only packages with a new major version

minor_only: bool

Only packages with a new minor version

patch_only: bool

Only packages with a new patch version

no_dev: bool

Skip dev dependencies

strict: bool

Exit non-zero if any package is outdated

working_dir: Option<PathBuf>

Run in this directory instead of CWD (-d)

Sync

Install everything the project requires

Fields

offline: bool

Don’t try to download anything, this will fail if there are uncached packages

dry_run: bool

Show the plan, change nothing on disk

scripts: bool

Run composer.json root scripts for this sync, overriding [scripts] run in bougie.toml. Off by default (opt-in)

no_scripts: bool

Skip composer.json root scripts for this sync, overriding [scripts] run = true in bougie.toml

resolution: ResolutionStrategy

Version-preference policy when a fresh lock must be resolved. No effect when a composer.lock already exists

patches: bool

Apply patches for this sync, overriding [patches] enable. On by default when patches are declared

no_patches: bool

Skip native patch application for this sync

php: PhpPrefArgs

Run

Run a command or script

Fields

with: Vec<String>

Add a temporary extension for this invocation

no_sync: bool

Skip the implicit bougie sync before running

xdebug: bool

Layer the server’s debug overlay (vendor/bougie/conf.d-debug/) into PHP_INI_SCAN_DIR and set XDEBUG_SESSION=1 for the child. Installs xdebug on first use if not already present

php_request: Option<String>

Run with a specific PHP interpreter. Accepts a version (8.3, 8.3.12), a constraint (~8.3, >=8.2,<8.4), or a path to a php binary. Forces a sync to that interpreter, so it can’t be combined with --no-sync

php: PhpPrefArgs

argv: Vec<String>

Command and arguments. -- separator is optional

Php(PhpCommand)

Manage PHP interpreters

Node(NodeCommand)

Manage Node.js interpreters

Composer(ComposerCommand)

Manage PHP packages with a composer compatible interface

Tool(ToolCommand)

Run and install commands provided by PHP packages

ToolExec

Runtime shim invoked by tool wrappers (#!.../bougie tool-exec). Not for direct CLI use; hidden from --help

Fields

wrapper: PathBuf

Path to the tool wrapper script the kernel handed us as argv[1] via the shebang

args: Vec<OsString>

User-supplied arguments to the tool, passed through to PHP

Cache(CacheCommand)

Manage bougie’s cache

SelfCmd(SelfCommand)

Manage the bougie binary itself

Server(ServerArgs)

Run the bougie development HTTP server

Services(ServicesCommand)

Manage project-scoped dev services

Projects(ProjectsCommand)

Inspect and manage provisioned tenants

Start

Bring the whole project up

Fields

no_sync: bool

Skip the implicit bougie sync prologue

dry_run: bool

Show what would run, but don’t execute

explain: bool

Explain why each step runs or skips

no_builtin: bool

Ignore the builtin recipe; use only bougie.toml

recipe: Option<String>

Force a specific builtin (e.g. magento)

Stop

Bring the project down

Fields

names: Vec<String>

Service names to stop. Empty = every declared service

purge: bool

Destroy persisted tenant data (e.g. FLUSHDB on redis). Off by default — bougie start should restore state

Make

Run project tasks

Fields

task: Option<String>

Task to run. With none, the available tasks are listed

list: bool

List available tasks instead of running

dry_run: bool

Show what would run, but don’t execute

explain: bool

Explain why each step runs or skips

no_sync: bool

Skip the implicit bougie sync prologue

no_builtin: bool

Ignore the builtin recipe; use only bougie.toml

recipe: Option<String>

Force a specific builtin (e.g. magento)

print: bool

Print the merged recipe to stdout instead of running

Format

Format the project’s PHP code

Fields

args: Vec<OsString>

Arguments forwarded verbatim to wick (paths, --check, --diff, - for stdin, …)

Trait Implementations

impl Debug for Command

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

Formats the value using the given formatter.

impl FromArgMatches for Command

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<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Command

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

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

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

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

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand