# ExecuteSoft CLI

`exe` is the Rust command-line tool for ExecuteSoft repository automation. Keep
workflow logic here instead of adding new Bash or Makefile implementations.

## Local Use

From the repository root, build the local binary:

```bash
make cli
```

Run it from `bin/exe`:

```bash
./bin/exe service check-all
./bin/exe service create --name recommendation-engine --domain core --template rust
./bin/exe gateway generate
./bin/exe dev up
```

Run without building `bin/exe`:

```bash
cargo run -p executesoft --bin exe -- service check-all
```

Install for the current user:

```bash
cargo install --path tools/exe
exe service check-all
```

If `exe` is not found after installation, add Cargo binaries to the shell path:

```bash
export PATH="$HOME/.cargo/bin:$PATH"
```

## Use Cases

### Check Service Compliance

Use this before committing service or template changes:

```bash
exe service check services/core/auth
exe service check-all
```

`check-all` validates service roots under `services/` and certified template
skeletons under `tools/templates/`.

### Create A Service

Use the generator instead of copying service folders manually:

```bash
exe service create \
  --name recommendation-engine \
  --domain core \
  --template rust \
  --owner-team team-recommendation-engine
```

The generator copies the selected certified template, replaces template tokens,
creates the service folder, and creates the shared protobuf contract when the
local service contract exists.

### Run Service Make Targets

Use service names for common operations:

```bash
exe service test auth
exe service build gateway
exe service generate notification
exe service clippy services/core/auth
```

When a service name is ambiguous, pass the service path.

### Manage Gateway Routes

Generated gateway artifacts must come from route source files and protobufs:

```bash
exe gateway route create --service auth
exe gateway route from-proto --service auth
exe gateway route entry --service auth --rpc Login
exe gateway generate
```

Do not manually edit generated route artifacts.

### Run Local Development Helpers

```bash
exe dev up
exe dev all
exe dev down
exe dev logs
exe dev watch -- cargo run
```

Use `dev watch` for simple polling reloads in services that need it.

### Release And Deployment

`release` and deployment commands keep repository sync first-class:

```bash
exe sync
exe release tag=latest
exe deploy kubernetes tag=latest
```

`deploy kubernetes` runs `sync` before delegating to the deployment Make target.

## crates.io Publishing

The crate is publish-enabled in `tools/exe/Cargo.toml`:

```toml
publish = true
```

To publish, first update `tools/exe/Cargo.toml` with public package metadata:

```toml
[package]
name = "executesoft"
version = "0.1.0"
edition = "2024"
rust-version = "1.95"
description = "ExecuteSoft repository automation CLI"
license = "MIT"
repository = "https://github.com/execute-soft/executsoft"
readme = "README.md"
publish = true
```

The package name is global on crates.io. If `executesoft` is unavailable,
choose another package name. The installed binary can still be named `exe`
because the binary target controls the command name:

```toml
[[bin]]
name = "exe"
path = "src/main.rs"
```

Authenticate and verify:

```bash
cargo login
cargo package --manifest-path tools/exe/Cargo.toml --list
cargo publish --manifest-path tools/exe/Cargo.toml --dry-run
```

Publish:

```bash
cargo publish --manifest-path tools/exe/Cargo.toml
```

After publishing, install from crates.io:

```bash
cargo install executesoft
exe service check-all
```

For private company tooling, prefer local or private-registry installation until
the command surface and package metadata are stable.
