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),
    Add {
        packages: Vec<String>,
        dev: bool,
        with_dependencies: bool,
        with_all_dependencies: bool,
        no_sync: bool,
        frozen: bool,
        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 {
        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,
        php: PhpPrefArgs,
    },
    Up {
        names: Vec<String>,
        detach: bool,
    },
    Down {
        names: Vec<String>,
        purge: bool,
    },
    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),
    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 (sync the toolchain + vendor, then run the project recipe). Unix-only.

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. Unix-only.

Ext(ExtCommand)

Manage PHP extensions.

Add

Add one or more packages to the project and sync. The uv-flavored twin of composer require: a bare vendor/pkg writes a >=X.Y lower bound (vs composer require’s caret ^X.Y), and an explicit constraint uses the @ syntax (vendor/pkg@^1.0), as in bougie tool install / bougie ext add. Edits composer.json, re-resolves composer.lock, and installs into vendor/.

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/.

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 one or more packages from the project and sync. The uv-flavored twin of composer remove.

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

Refresh composer.lock to match composer.json (native; uv’s uv lock). Minimal: keeps every package at its locked version where still valid, re-resolving only what changed. Never bumps versions and never installs — use bougie composer update to pull newer versions.

Fields

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

Print the project’s dependency tree (native; uv’s uv tree). Reads composer.lock.

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 a newer version available (native; like uv/pnpm outdated). Reads composer.lock and queries the configured repositories.

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.

php: PhpPrefArgs

Up

Start the project’s declared services (or every service in names) and provision the project’s tenant in each. Equivalent to the former bougie services up — promoted to a top-level verb because it’s the most common project-startup step.

Fields

names: Vec<String>

Service names to bring up. Empty = every declared service.

detach: bool

Start the services and return immediately instead of attaching to their combined log stream. Attaching is the default for an interactive (TTY) text-mode invocation; non-interactive runs and --format json-v1 always detach.

Down

Stop the project’s declared services (or every service in names). The shared global process stays up while any other project’s tenant remains. Equivalent to the former bougie services down.

Fields

names: Vec<String>

purge: bool

Destroy persisted tenant data (e.g. FLUSHDB on redis). Off by default — re-adding the service should restore state.

Run

Run a command in the project environment.

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. Mirrors uv run --python.

php: PhpPrefArgs

argv: Vec<String>

Command and arguments. -- separator is optional.

Php(PhpCommand)

Manage PHP interpreters.

Node(NodeCommand)

Manage Node.js interpreters (for projects that build frontend assets — Vite, Laravel Mix, Magento static-content deploy).

Composer(ComposerCommand)

Run Composer, reimplemented natively. bougie does not bundle or execute the Composer phar; the common Composer surface (install/update/require/remove/show/why/why-not/outdated/audit/ licenses/fund/status/validate/dump-autoload) runs natively, and an unrecognized subcommand errors with a pointer to bougie tool install composer/composer for the full upstream Composer.

Tool(ToolCommand)

Manage globally-installed, isolated PHP CLI tools. See TOOL_PLAN.md for the design.

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 for the current project. With no subcommand, registers the project with the shared dev server, prints its URL, and streams its log (Ctrl-C detaches). See SERVER.md.

Services(ServicesCommand)

Manage project-scoped dev services (mariadb, redis, …). See SERVICES.md and CLI.md §3.8.

Projects(ProjectsCommand)

Inspect and manage provisioned tenants across the shared dev services and the project each belongs to. Reads the on-disk tenant ledgers; no daemon required.

Make

Walk a project recipe’s DAG, running tasks whose freshness check fails. bougie start is a zero-arg alias for bougie make start. See RECIPES.md.

Fields

task: Option<String>

Task to run. Defaults to start — so bougie make and bougie start are equivalent.

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, the way uv format runs ruff.

bougie does not bundle a formatter: on first use it downloads a pinned wick binary (cresset-tools/wick — an unconfigurable, Laravel Pint-style formatter), caches it, and execs it. Every argument is forwarded verbatim to wick, so bougie format, bougie format --check, bougie format src/ --diff, and … | bougie format - behave exactly like the matching wick invocation. Pin a specific wick with BOUGIE_WICK_VERSION.

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