Usage

Once installed, curo provides a simple, unified CLI for common development workflow tasks. Typical commands are:

curo build         # Build your project or component(s)
curo test          # Run tests
curo deploy        # Deploy built artifacts

You can always see the available actions by running:

curo --help

Command Structure

Every invocation follows one grammar:

curo [flags] <action> [component-path] [-- args...]

<action>: one of the standard actions below, as a single token.
[component-path]: optionally target one component, addressed by a slash path such as curo/cli. No path means the whole tree from the root.
[-- args...]: everything after -- is passed through to the underlying command untouched.
flags can go anywhere; see Advanced Usage.

The Actions

The action vocabulary is fixed. Every action has a short alias.

Action	Alias	Meaning
`install`	`i`	Install the environment
`build`	`b`	Build some code
`lint`	`l`	Check for linting and typing code
`format`	`f`	Format some code
`generate`	`g`	Generate code from a template or specification
`clean`	`c`	Clean up the environment
`start`	`st`	Start an application detached
`run`	`rn`	Execute and tail an application
`stop`	`sp`	Stop a detached application
`restart`	`r`	Quickly restart an application
`status`	`ss`	Check whether any applications are running
`test`	`t`	Test some code
`log`	`lg`	Tail the logs of a running application
`publish`	`p`	Publish an artifact
`deploy`	`d`	Deploy the artifact

There are no user-defined actions. If a component needs a command, it lives under one of these names.

Common Workflow

Install project dependencies
```
curo install
```
Build the project
```
curo build
```
Run tests
```
curo test
```
Start your project
```
curo start
```

Targeting a Component

Component paths are single tokens with slashes, and they tab-complete:

curo build curo/cli
curo start backend/server

Test Sublevels

test is the one action that fans out. A bare curo test runs every defined sublevel in order: unit, integration, then functional. Select one with a dotted token:

curo test.unit
curo test.functional backend/server

Skip a sublevel from the fan-out with --without:

curo test --without functional

Chaining Commands

Chain additional action tokens onto one invocation with -n/--and:

curo format -n lint -n build -n test.unit

Passing Extra Arguments

Everything after -- goes to the resolved command verbatim, where the manifest chooses to use it:

curo test.functional curo/cli -- -k test_smoke
curo deploy curo/cli -- prod

Deploy and publish targets are deliberately arguments, not configuration: the script owns target validation.

CURO Documentation