heddle-cli 0.15.1

[package]
name = "heddle-cli"
version.workspace = true
edition.workspace = true
authors.workspace = true
description.workspace = true
license.workspace = true
repository.workspace = true
keywords.workspace = true
categories.workspace = true
readme = "../../README.md"
# Exclude bulky integration-test fixtures (~24 MB of git-shaped tarballs)
# from the published tarball — they push the package over crates.io's
# 10 MB limit and only matter for tests run inside the workspace.
exclude = [
    "tests/realworld_git/fixtures/*",
    "tests/snapshots/**/*",
]

[dependencies]
agent-relay.workspace = true
anyhow.workspace = true
base64.workspace = true
getrandom.workspace = true
blake3.workspace = true
chrono.workspace = true
ci-config = { workspace = true, optional = true }
ci-engine = { workspace = true, optional = true }
clap.workspace = true
clap_complete.workspace = true
futures.workspace = true
hex.workspace = true
ignore.workspace = true
libc.workspace = true
objects.workspace = true
crypto.workspace = true
# `heddle-merge` is the native hunk-level text merge engine extracted from
# `heddle-semantic` so non-semantic builds (`--no-default-features`) retain
# text auto-merge. Always-on: the merge driver and rebase replay both call
# into it unconditionally.
merge.workspace = true
api = { workspace = true }
config.workspace = true
hosted-client.workspace = true
heddle-cli-args.workspace = true
heddle-cli-contract.workspace = true
heddle-cli-render.workspace = true
verbs.workspace = true
heddle-format.workspace = true
async-trait.workspace = true
# `default-features = false` here matches the pattern used for
# repo below: this crate's `zstd` feature controls the cascade
# end-to-end. Without these breaks, every dep's own default-on `zstd`
# would re-enable compression even when the user explicitly built
# with `--no-default-features`.
ingest.workspace = true
heddle-git-projection.workspace = true
oplog.workspace = true
wire.workspace = true
refs.workspace = true
repo.workspace = true
semantic = { workspace = true, optional = true }
notify.workspace = true
opentelemetry = { workspace = true, optional = true }
opentelemetry-otlp = { workspace = true, optional = true }
opentelemetry_sdk = { workspace = true, optional = true }
prost.workspace = true
prost-types.workspace = true
rmp-serde.workspace = true
schemars.workspace = true
serde.workspace = true
serde_json.workspace = true
heddle-perf-contract.workspace = true
sha2.workspace = true
sley.workspace = true
tempfile.workspace = true
thiserror.workspace = true
tokio.workspace = true
tokio-tungstenite = { workspace = true, optional = true }
toml.workspace = true
# `uuid::Uuid::new_v4().simple()` suffixes rebase transaction ids
# (`rebase_ops::mint_rebase_transaction_id`) so a nanosecond-resolution
# clock collision can't silently drop the later rebase's batch via
# `flush_rebase_batch`'s dedup (heddle#198 r3 / Codex PR #218 P2).
# `v5` derives deterministic per-thread push client_operation_ids (remote::push).
uuid = { workspace = true, features = ["v5"] }
rustls.workspace = true
tracing.workspace = true
tracing-opentelemetry = { workspace = true, optional = true }
tracing-subscriber.workspace = true
walkdir.workspace = true

# Mount is platform-agnostic in source, but each adapter only
# compiles for one OS — FUSE on Linux (`fuse`), FSKit on macOS
# (`fskit`), ProjFS on Windows (`projfs`). We take the `mount`
# dep on each target separately so the CLI's `mount` feature can
# propagate the right per-OS backend without any one platform
# being forced to drag in another platform's kernel bindings.
[target.'cfg(target_os = "linux")'.dependencies]
mount = { workspace = true, optional = true }

[target.'cfg(target_os = "macos")'.dependencies]
mount = { workspace = true, optional = true }

[target.'cfg(target_os = "windows")'.dependencies]
mount = { workspace = true, optional = true }

[features]
# The default `heddle` build ships the full workflow: local
# invisible-VCS plus the hosted `client` surface (push / clone / pull,
# discussions, context, review against a weft server). `client` is in
# the default set because the hosted flows are now core to how heddle
# is used — gating them behind `--features client` turned a first-run
# `heddle clone <hosted-url>` / `heddle push` into an opaque error. A
# slim, local-only build stays available via `--no-default-features
# --features git-overlay,native,semantic,zstd`. `semantic` is included
# in defaults because
# `heddle diff --semantic` and the
# agent-loop self-review all reach for it; gating
# the default install behind an extra `--features semantic` flag
# turns these documented commands into an opaque error for first-run
# users. The binary cost is the four `tree-sitter-*` parsers
# (Rust/Python/JS/TS) — a small fraction of the existing footprint
# from the hosted client stack. `semantic-extended` (Go/C/C++/Java) stays
# opt-in.
# `mount` is in the default set so a stock `cargo install heddle-cli`
# (or `cargo install --path crates/cli`) ships `heddle-fuse-worker`
# next to `heddle`. Without it, the sibling-binary lookup in
# `mount::worker::default_worker_binary` doesn't resolve and the
# mount lifecycle silently falls back to NFS on every Linux user
# who installed via the documented flow (heddle#190 r5 / Codex PR
# #225 P2). The platform-specific backends (`fuser` on Linux,
# `windows` on Windows, `cbindgen`/Swift on macOS) are target-gated
# inside `heddle-mount`, so default-on is platform-blind: each host
# pulls only its own native adapter plus the platform-agnostic NFS
# fallback (`nfsserve` + `tokio` async-trait). The OSS feature
# subsets that explicitly want a slim build (`--no-default-features
# --features git-overlay,...`) opt out the same way they do today.
default = [
    "git-overlay",
    "native",
    "local",
    "mount",
    "semantic",
    "zstd",
    "client",
]
# `ci` gates the local `heddle ci` executor (constitutional later after
# treadle). Non-default: the everyday loop never invokes it, and the
# default binary should not carry the check runner.
ci = [
    "dep:ci-config",
    "dep:ci-engine",
    "heddle-cli-args/ci",
    "heddle-cli-contract/ci",
]
local = []
# Repository mode features. At least one must be enabled. The default
# build enables both modes plus the hosted `client`. Slimmer builds opt
# out via `--no-default-features`: `git-overlay` only (works on top of
# existing Git repos; no native content-addressed init), `native` only
# (pure content-addressed VCS; no Git Projection import/export surface),
# or both — and each can drop `client` for a local-only CLI.
git-overlay = [
    "repo/git-overlay",
    "ingest",
    "heddle-cli-args/git-overlay",
    "heddle-cli-contract/git-overlay",
]
native = ["repo/native"]
# `client` is now a marker: the hosted stack itself (Iroh transport,
# credentials, biscuits, websockets, hosted sync) compiles inside
# `hosted-client`; enabling this just turns that crate's `client` feature on
# alongside the CLI-side client-gated surfaces.
client = [
    "api/reflection",
    "agent-relay/client",
    "dep:tokio-tungstenite",
    "hosted-client/client",
    "heddle-cli-args/client",
    "heddle-cli-contract/client",
    "heddle-cli-render/client",
]
# Deep git import + AI-session reasoning extraction now backs every Git
# overlay import path. Kept as a feature name for existing feature sets,
# but the dependency is always present so no legacy bridge importer is
# compiled as a fallback.
ingest = ["heddle-cli-args/ingest", "heddle-cli-contract/ingest"]
semantic = [
    "dep:semantic",
    "heddle-cli-args/semantic",
    "heddle-cli-contract/semantic",
    "verbs/semantic",
    "repo/tree-sitter-symbols",
]
semantic-extended = ["semantic", "verbs/semantic-extended", "semantic?/extended-languages"]
# `telemetry` compiles OTLP support into the CLI. It stays opt-in so the
# default binary does not carry the exporter and HTTP/TLS dependency stack.
# Runtime initialization remains endpoint-gated when the feature is enabled.
telemetry = [
    "config/telemetry",
    "dep:opentelemetry",
    "dep:opentelemetry-otlp",
    "dep:opentelemetry_sdk",
    "dep:tracing-opentelemetry",
    "hosted-client/telemetry",
]
# Forward zstd compression to every layer that touches the pack
# format. The `?` syntax on optional deps activates the feature only
# when the dep itself is enabled (`ingest` is gated behind
# the `ingest` feature).
zstd = [
    "objects/zstd",
    "wire/zstd",
    "repo/zstd",
    "ingest/zstd",
    "heddle-git-projection/zstd",
    "verbs/zstd",
]
# Wire the content-addressed mount through the CLI. Off by
# default — each native backend pulls in a kernel-side dep that
# only exists on its target OS (`fuser` on Linux, `swiftc`-compiled
# FSKit shim on macOS, `windows` crate's ProjFS bindings on
# Windows). Activate with `cargo build --features mount` on any
# of the three; the per-target cfg gates in `crates/mount/src/lib.rs`
# select the correct native backend. Cargo features are
# platform-blind so all backend features propagate from this one —
# the inactive ones compile to zero code via the cfg gates.
#
# The `nfs` feature is the universal fallback: a platform-agnostic
# adapter that stands up an in-process NFSv3 server and asks the
# host's built-in NFS client to mount it. The CLI's mount
# lifecycle prefers the host's native adapter and falls back to
# NFS at runtime when the native one is unavailable (missing
# kernel module, missing System Extension, missing optional
# feature, etc).
mount = [
    "dep:mount",
    "mount?/fuse",
    "mount?/fskit",
    "mount?/projfs",
    "mount?/nfs",
]

[dev-dependencies]
# Test-only: hosted fixtures mint biscuits and stand up Iroh endpoints
# directly; the production CLI gets both through `hosted-client`.
biscuit-auth.workspace = true
iroh.workspace = true
criterion = "0.8"
heddle-cli-render = { workspace = true, features = ["default", "test-utils"] }
hyper-util.workspace = true
# Test-only: the in-memory object backend never ships in the binary.
objects = { workspace = true, features = ["memory-backend"] }
iroh-relay = { version = "=1.0.3", default-features = false, features = ["server"] }
ntest.workspace = true
prost-reflect.workspace = true
proptest.workspace = true
rcgen = "0.14.8"
tokio-tungstenite.workspace = true
serial_test.workspace = true
uuid.workspace = true

[[bin]]
name = "heddle"
path = "src/main.rs"

[[bin]]
name = "heddle-fsmonitor-worker"
path = "src/bin/heddle-fsmonitor-worker.rs"

# Linux-only crash-isolation worker. Co-located in the CLI package
# so `cargo install --path crates/cli` (and `cargo install heddle`
# from crates.io) installs both `heddle` and `heddle-fuse-worker`
# into the same bin dir — the sibling-binary lookup in
# `mount::worker::default_worker_binary` only resolves when the two
# ship together. The file itself is `cfg(target_os = "linux",
# feature = "mount")`, so non-Linux and mount-less builds compile to
# nothing here.
[[bin]]
name = "heddle-fuse-worker"
path = "src/bin/heddle-fuse-worker.rs"
required-features = ["mount"]

[[bin]]
name = "heddle-ingest"
path = "src/bin/heddle-ingest.rs"
required-features = ["ingest"]

[lib]
name = "cli"
path = "src/lib.rs"

# Integration tests for cli live under `tests/` (auto-discovered) so
# that `cargo publish` can package the crate cleanly.

[[test]]
name = "ci_run_local"
path = "tests/ci_run_local.rs"
required-features = ["ci"]

[[test]]
name = "semantic_diff_integration"
path = "tests/semantic_diff_integration.rs"
required-features = ["semantic"]

[[test]]
name = "semantic_symbol_diff_cli"
path = "tests/semantic_symbol_diff_cli.rs"
required-features = ["semantic"]

[[test]]
name = "semantic_refs_cli"
path = "tests/semantic_refs_cli.rs"
required-features = ["semantic"]

[[bench]]
name = "local_ops"
harness = false
required-features = ["semantic"]

[[bench]]
name = "capture_allocations"
harness = false

[[bench]]
name = "clonefile_threads"
harness = false