Unified Rust workspace consolidating the entire trusty-* AI tooling ecosystem.
It combines code search, memory, analysis, orchestration, review, and
operator interfaces in one Cargo workspace. The live package inventory comes
from ; the human-readable map is
.
Unified Rust workspace for the trusty-* AI developer-tooling ecosystem: hybrid code search, memory palace, code analysis, PR review, and the MPM multi-agent platform — MCP servers, daemons & CLIs.
PM-style multi-agent orchestration over coding work: manages multi-project
sessions, relays hooks, and exposes an MCP server to Claude Code sessions,
delegating coding tasks to trusty-code.
What you get:
PM-style orchestration of Claude Code sessions, delegating coding tasks to
specialist agents such as trusty-code (tcode)
Multi-project session management with hook relaying
An MCP server exposed to Claude Code sessions
A TUI dashboard (tm tui) and a Telegram bot (tm telegram pair)
Long-term memory storage with semantic search, persistent embedding index, and embedded Svelte UI. Store development context, notes, snippets, and retrieve them via natural language.
What you get:
Pure-Rust HNSW vector index (hnsw_rs) persisted in redb + fastembed embeddings
Machine-wide code search daemon with hybrid BM25 + vector + knowledge-graph fusion, fused via Reciprocal Rank Fusion. One install per machine, unlimited named project indexes.
What you get:
Sub-10ms p50 warm query latency on 100k-chunk indexes
Fast local PR-review service: LLM-backed code review with search and analysis
context, reviewing GitHub PRs and unified diffs via AWS Bedrock or OpenRouter.
What you get:
Fetches GitHub PR diffs, retrieves code context from trusty-search and
complexity data from trusty-analyze, then calls an LLM to produce a
structured review verdict
Ships as a one-shot CLI (run / compare), a JSON-RPC 2.0 / MCP stdio
service (mcp), and a per-delivery webhook drain spawned by trusty-console
Dry-run by default — posting a PR comment requires an explicit --live flag
Static code-analysis sidecar for trusty-search: cyclomatic and cognitive
complexity, code smells, quality grading, git temporal decay, concept clustering,
SCIP protobuf ingest, and a (subject, predicate, object) facts store backed by
redb. It reads its chunk corpus from trusty-search over HTTP, serves daemon RPC
over a Unix socket, and exposes MCP over stdio.
What you get:
Cyclomatic + cognitive complexity per chunk / file / index
Configurable code-smell categories with named thresholds
Unix-socket JSON-RPC + MCP parity (every method has a tool equivalent)
Quick start:
# 1. trusty-search must be running first — it is a hard runtime dependency
cargo run -p trusty-search -- start
# 2. start the analyze sidecar
cargo run -p trusty-analyze -- --search-url http://127.0.0.1:7878 start
# 3. analyze a named index
cargo run -p trusty-analyze -- analyze <index-id> --top-k 20
The five flagship crates above have their own README links and quick starts.
This is an orientation map for the rest of the workspace, not a second package
registry. For package names, versions, publishability, and targets, use
cargo metadata --no-deps --format-version 1; for direct links from every
package to its manifest, source, and documentation, use the
crate map.
Deterministic personal knowledge-base store + MCP server
trusty-publish-guard
Internal release parity checker
trusty-sld-lint
Spec-linked documentation linter
trusty-embedderd-py
Optional Python/MPS embedding sidecar launcher
Analytics & Orchestration
Crate
Description
trusty-agents
Agent orchestration platform
trusty-agents-common
Shared types and utilities for agent framework
trusty-agents-ui
Nested Tauri desktop client for trusty-agents
Moved to their own repo
tga (git analytics, formerly the crates/trusty-git-analytics directory) and
trusty-audit (auditor handoff client, bins trusty-audit and taudit, plus
trusty-audit-ui) build, release and publish from
bobmatnyc/trusty-git-analytics.
tctl install tga still installs tga; tctl install does not take
trusty-audit by name.
This is a role view, not a dependency graph. Cargo manifests are authoritative
for compile-time edges; runtime edges are documented in the
crate map and the relevant crate README.
Install the full trusty-tools platform with one command (no Rust toolchain required):
curl -sSf https://raw.githubusercontent.com/bobmatnyc/trusty-tools/main/install.sh | sh
This downloads the prebuilt trusty-installer binary (SHA-256 verified), installs it to ~/.local/bin, and runs trusty-installer install to set up the rest of the platform (search, memory, analyze, review, console). The tctl transitional alias is also installed, so existing muscle-memory commands (tctl install, tctl status, etc.) continue to work.
Non-interactive (CI / scripted):
curl -sSf https://raw.githubusercontent.com/bobmatnyc/trusty-tools/main/install.sh | sh -s -- -y
Options (environment variables):
Variable
Effect
TRUSTY_VERSION
Pin a specific version (e.g. 0.2.0)
TRUSTY_INSTALL_DIR
Override the install directory (default ~/.local/bin)
TRUSTY_YES=1
Skip all prompts (same as -y)
TRUSTY_FORCE=1
Re-download even if already installed (same as --force)
TRUSTY_NO_MODIFY_PATH=1
Don't modify your shell PATH
Supported platforms: macOS (Apple Silicon), Linux x86_64, and Linux arm64 (aarch64-unknown-linux-gnu). macOS Intel is not supported — build from source with cargo install trusty-installer.
Security: The installer is served over HTTPS and every downloaded binary is SHA-256 verified against its published checksum. The installer script itself is not signed — review it before running if you require higher assurance: https://github.com/bobmatnyc/trusty-tools/blob/main/install.sh
With tctl (the control plane)
tctl — the trusty-installer binary the bootstrap script above puts on your
PATH — is the recommended route for its managed application set:
trusty-search, trusty-memory, trusty-analyze, trusty-review,
trusty-console, trusty-mpm, and tga. It installs them, upgrades them
together, knows which run as daemons, and can update its own control-plane
binary. The live set is defined in
stable_set.rs.
tga comes from
bobmatnyc/trusty-git-analytics
releases, with cargo install from crates.io as the fallback.
tctl install # the full managed set
tctl install trusty-search # one member
tctl install trusty-search --dry-run
tctl status # what is installed, and which daemons are up
Homebrew below is the alternative when you want one binary and nothing else.
With Homebrew
Installs individual trusty-* binaries via package manager. First, add the tap:
If you prefer to build from the latest source or need a crate not distributed via Homebrew:
git clone https://github.com/bobmatnyc/trusty-tools
cd trusty-tools
# Build all crates
cargo build --release
# Run all tests
cargo test
# Install the CLI tools
cargo install --path crates/trusty-search --locked
# More tools available via: cargo install --path crates/<crate>
Build & Test Commands
cargo build # all crates, debug
cargo check -p <crate-name> # fastest crate-scoped check
cargo test -p <crate-name> --no-fail-fast # every target in one crate
cargo clippy -p <crate-name> --all-targets -- -D warnings
cargo fmt --check
See CLAUDE.md for feature-gated crates and the risk-based test
ladder. A bare workspace test is a hardening gate, not the normal inner loop.
Workspace Info
Single source of truth: Every crate is co-located under crates/ with one workspace root and one Cargo.lock, so a change spanning several of them is one commit.
MSRV: Rust 1.94+ (required by the aws-config / aws-sdk-bedrockruntime dependencies)
License: the workspace package default is MIT. Each package manifest remains
authoritative, including nested private UI packages that may not inherit the
workspace field.