heddle-cli 0.11.0

[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]
anyhow.workspace = true
base64.workspace = true
biscuit-auth = { workspace = true, optional = true }
blake3.workspace = true
bytes = { workspace = true, optional = true }
chrono.workspace = true
clap.workspace = true
clap_complete.workspace = true
futures.workspace = true
hex.workspace = true
ignore.workspace = true
iroh = { workspace = true, optional = true }
iroh-base = { workspace = true, optional = true }
libc.workspace = true
n0-watcher = { workspace = true, optional = true }
noq-udp = { workspace = true, optional = true }
objects = { path = "../objects", package = "heddle-objects", version = "0.11", features = ["memory-backend"] }
crypto = { path = "../crypto", package = "heddle-crypto", version = "0.11" }
daemon = { path = "../daemon", package = "heddle-daemon", version = "0.11" }
# `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 = { path = "../merge", package = "heddle-merge", version = "0.11" }
api = { package = "heddle-api", version = "0.2.1" }
cli-shared = { path = "../cli-shared", package = "heddle-cli-shared", version = "0.11" }
heddle-cli-args = { path = "../cli-args", version = "0.11", default-features = false }
heddle-cli-contract = { path = "../cli-contract", version = "0.11", default-features = false }
heddle-cli-render = { path = "../cli-render", version = "0.11", default-features = false }
heddle-core = { path = "../core", version = "0.11", default-features = false }
heddle-format = { path = "../format", version = "0.11" }
weft-client-shim = { path = "../weft-client-shim", package = "weft-client-shim", version = "0.11" }
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 = { path = "../ingest", package = "heddle-ingest", version = "0.11", default-features = false }
heddle-git-projection = { path = "../git-projection", version = "0.11", default-features = false }
oplog = { path = "../oplog", package = "heddle-oplog", version = "0.11" }
wire = { path = "../wire", package = "heddle-wire", version = "0.11", default-features = false }
refs = { path = "../refs", package = "heddle-refs", version = "0.11" }
repo = { path = "../repo", package = "heddle-repo", version = "0.11", default-features = false }
semantic = { path = "../semantic", package = "heddle-semantic", version = "0.11", 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
rand = { workspace = true, optional = true }
reqwest = { workspace = true, optional = true }
rmp-serde.workspace = true
schemars.workspace = true
serde.workspace = true
serde_json.workspace = true
sha2.workspace = true
sley.workspace = true
tempfile.workspace = true
thiserror.workspace = true
tokio.workspace = true
tokio-stream = { workspace = true, optional = 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
webpki-roots = { workspace = true, optional = 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 = { path = "../mount", package = "heddle-mount", version = "0.11", optional = true }

[target.'cfg(target_os = "macos")'.dependencies]
mount = { path = "../mount", package = "heddle-mount", version = "0.11", optional = true }

[target.'cfg(target_os = "windows")'.dependencies]
mount = { path = "../mount", package = "heddle-mount", version = "0.11", 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"]
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 = [
    "api/reflection",
    "dep:biscuit-auth",
    "dep:bytes",
    "dep:iroh",
    "dep:iroh-base",
    "dep:n0-watcher",
    "dep:noq-udp",
    "dep:rand",
    "dep:reqwest",
    "dep:tokio-stream",
    "dep:tokio-tungstenite",
    "dep:webpki-roots",
    "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",
    "heddle-core/semantic",
    "repo/tree-sitter-symbols",
]
semantic-extended = ["semantic", "heddle-core/semantic-extended", "semantic?/extended-languages"]
observability = [
    "cli-shared/observability",
    "dep:opentelemetry",
    "dep:opentelemetry-otlp",
    "dep:opentelemetry_sdk",
    "dep:tracing-opentelemetry",
]
# 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",
    "heddle-core/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]
criterion = "0.8"
heddle-cli-render = { path = "../cli-render", version = "0.11", features = ["test-utils"] }
hyper-util.workspace = true
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 = "semantic_diff_integration"
path = "tests/semantic_diff_integration.rs"
required-features = ["semantic"]

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

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