chore: rename package and project to tooltrim

Author: false200

.dockerignore

@@ -16,7 +16,7 @@ coverage
 *.tsbuildinfo
 
 # Local runtime artifacts
-.leanmcp
+.tooltrim
 bench/sandbox
 bench/results/*.json
 bench/REPORT.md

.github/workflows/ci.yml

@@ -44,5 +44,5 @@ jobs:
       - name: Smoke-test the CLI
         shell: bash
         run: |
-          node bin/leanmcp --version
-          node bin/leanmcp measure --config examples/demo.config.json
+          node bin/tooltrim --version
+          node bin/tooltrim measure --config examples/demo.config.json

.gitignore

@@ -1,7 +1,7 @@
 node_modules/
 dist/
 coverage/
-.leanmcp/
+.tooltrim/
 *.log
 .DS_Store
 .env

.npmignore

@@ -9,4 +9,4 @@ vitest.config.ts
 .eslintrc*
 .prettierrc*
 coverage/
-.leanmcp/
+.tooltrim/

CONTRIBUTING.md

@@ -1,6 +1,6 @@
-# Contributing to LeanMCP
+# Contributing to Tooltrim
 
-Thanks for your interest! LeanMCP is a small project; a quick PR is usually faster than a long discussion.
+Thanks for your interest! Tooltrim is a small project; a quick PR is usually faster than a long discussion.
 
 ## Local setup
 
@@ -16,7 +16,7 @@ pnpm build
 ## Enterprise benchmark (optional)
 
 The numbers in [`bench/REPORT.md`](bench/REPORT.md) / the README hero come from
-**`pnpm bench` run inside the Docker image** (`Dockerfile` → `leanmcp:dev`) so
+**`pnpm bench` run inside the Docker image** (`Dockerfile` → `tooltrim:dev`) so
 the baseline is **linux-x64** with a pinned Node, not whatever laptop ran it
 last. See [`docs/DOCKER.md`](docs/DOCKER.md) for `docker build` / `docker run`
 and how to mount `bench/` so `REPORT.md` updates on the host.
@@ -48,8 +48,8 @@ Conventional commits are nice but not enforced. A short imperative summary is fi
 
 Please include:
 
-- the version of LeanMCP (`leanmcp --version`),
-- the **redacted** config (use `leanmcp validate-config` — it strips token-like fields),
-- a few lines of `.leanmcp/trace.ndjson` if relevant.
+- the version of Tooltrim (`tooltrim --version`),
+- the **redacted** config (use `tooltrim validate-config` — it strips token-like fields),
+- a few lines of `.tooltrim/trace.ndjson` if relevant.
 
 By contributing, you agree your work is licensed under the same [MIT license](LICENSE) as the project.

Dockerfile

@@ -1,12 +1,12 @@
-# LeanMCP — Linux container image
+# Tooltrim — Linux container image
 #
-# Default behavior: starts the LeanMCP proxy on 0.0.0.0:8799 (MCP Streamable HTTP)
+# Default behavior: starts the Tooltrim proxy on 0.0.0.0:8799 (MCP Streamable HTTP)
 # and 0.0.0.0:9464 (Prometheus). It fans out to five upstream MCP servers via
 # `npx`, so we warm the npm cache for those packages during build to make the
 # first call fast and self-contained.
 #
 # Override CMD to run the bench harness instead, e.g.:
-#   docker run --rm leanmcp:dev pnpm bench --skip-agent
+#   docker run --rm tooltrim:dev pnpm bench --skip-agent
 #
 # Multi-stage layout:
 #   1. deps    — install ALL dependencies (incl. dev) for build + bench
@@ -112,12 +112,12 @@ RUN set -eux; \
 
 # Filesystem upstream needs a sandbox dir; the bench config defaults to
 # /app/bench/sandbox via BENCH_FS_ROOT.
-RUN mkdir -p /app/bench/sandbox /app/bench/results /app/.leanmcp
+RUN mkdir -p /app/bench/sandbox /app/bench/results /app/.tooltrim
 
 EXPOSE 8799 9464
 
 # dumb-init reaps zombie children spawned by the upstream stdio servers.
 ENTRYPOINT ["/usr/bin/dumb-init", "--"]
 
 # Default: start the proxy. Override with `pnpm bench [...]` etc.
-CMD ["node", "bin/leanmcp", "start", "--config", "examples/benchmark.docker.config.yaml"]
+CMD ["node", "bin/tooltrim", "start", "--config", "examples/benchmark.docker.config.yaml"]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 LeanMCP contributors
+Copyright (c) 2026 Tooltrim contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,17 +1,17 @@
-# LeanMCP
+# Tooltrim
 
 > An open-source [Model Context Protocol](https://modelcontextprotocol.io) proxy that puts your tool list on a diet.
 > Aggregate N MCP servers, filter and shrink the noise, and trace every call.
 
-[![npm](https://img.shields.io/npm/v/leanmcp.svg)](https://www.npmjs.com/package/leanmcp)
+[![npm](https://img.shields.io/npm/v/tooltrim.svg)](https://www.npmjs.com/package/tooltrim)
 [![license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
 ## Why
 
 Connect three or four MCP servers in a single session and the **tool metadata alone routinely eats 40-50% of the context window** before the user has even typed a question.
 The MCP team's [2026 roadmap](https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/) explicitly calls out gateways, proxies, and observability as priority work.
 
-**LeanMCP** (`leanmcp` on npm) is a small, drop-in proxy that sits in front of N upstream MCP servers and:
+**Tooltrim** (`tooltrim` on npm) is a small, drop-in proxy that sits in front of N upstream MCP servers and:
 
 - **filters** their tool / resource / prompt lists down to the ones your project actually uses,
 - **shrinks** verbose tool descriptions and dedupes JSON-Schema sub-trees, deterministically,
@@ -24,7 +24,7 @@ It speaks both `stdio` and `Streamable HTTP` in both directions, runs stateless
 
 ## The hero
 
-Measured against five real, official `@modelcontextprotocol/*` servers (`server-everything` + `server-filesystem` + `server-memory` + `server-sequential-thinking` + `server-github`). The numbers below match the checked-in [`bench/REPORT.md`](bench/REPORT.md): full **`pnpm bench`** inside the **`leanmcp:dev` Docker image** (Debian bookworm, **linux-x64**, Node **20.18**), so CI and contributors get the same Linux-shaped baseline as the README—not a hand-tuned Windows-only run.
+Measured against five real, official `@modelcontextprotocol/*` servers (`server-everything` + `server-filesystem` + `server-memory` + `server-sequential-thinking` + `server-github`). The numbers below match the checked-in [`bench/REPORT.md`](bench/REPORT.md): full **`pnpm bench`** inside the **`tooltrim:dev` Docker image** (Debian bookworm, **linux-x64**, Node **20.18**), so CI and contributors get the same Linux-shaped baseline as the README—not a hand-tuned Windows-only run.
 
 ```text
 Scenario                Tools  Bytes   Tokens  vs raw (tokens)
@@ -35,7 +35,7 @@ task   (filter+shrink)      3   3,165     656        −93.7%
 
 Proxy round-trip overhead  +3.7 ms p50 / +6.7 ms p95  (tools/call, bench harness loopback inside container)
 Throughput                 50 concurrent calls,  0 errors,  ~271 ops/sec
-Agent (Claude Sonnet 4.5)  ~77% fewer cumulative input tokens (direct vs LeanMCP task filter) — see report §5
+Agent (Claude Sonnet 4.5)  ~77% fewer cumulative input tokens (direct vs Tooltrim task filter) — see report §5
 ```
 
 Full reproducible report: [`bench/REPORT.md`](bench/REPORT.md). Run the harness on the host with `pnpm bench`, or in Docker (same numbers on Linux) — see [`docs/DOCKER.md`](docs/DOCKER.md) and [`bench/README.md`](bench/README.md).
@@ -46,34 +46,34 @@ Full reproducible report: [`bench/REPORT.md`](bench/REPORT.md). Run the harness
 
 ```bash
 # 1. install (no global, no daemon, just npx)
-pnpm dlx leanmcp --version    # or: npx leanmcp --version
+pnpm dlx tooltrim --version    # or: npx tooltrim --version
 
 # 2. drop a config in your repo root
-cp node_modules/leanmcp/examples/leanmcp.config.yaml .
+cp node_modules/tooltrim/examples/tooltrim.config.yaml .
 
-# 3. point your MCP client at LeanMCP instead of the individual servers
+# 3. point your MCP client at Tooltrim instead of the individual servers
 ```
 
 Cursor / Claude Desktop / Codex stdio config:
 
 ```json
 {
   "mcpServers": {
-    "leanmcp": {
+    "tooltrim": {
       "command": "npx",
-      "args": ["-y", "leanmcp"]
+      "args": ["-y", "tooltrim"]
     }
   }
 }
 ```
 
-That's it. `leanmcp` will read `leanmcp.config.yaml` from the cwd, fan out to every upstream listed there, and present a single merged, filtered, shrunk tool list to your client.
+That's it. `tooltrim` will read `tooltrim.config.yaml` from the cwd, fan out to every upstream listed there, and present a single merged, filtered, shrunk tool list to your client.
 
 ---
 
 ## Configuration
 
-A complete example lives in [`examples/leanmcp.config.yaml`](examples/leanmcp.config.yaml).
+A complete example lives in [`examples/tooltrim.config.yaml`](examples/tooltrim.config.yaml).
 
 ```yaml
 servers:
@@ -97,7 +97,7 @@ shrink:
   mode: rules                    # rules | off | llm (v0.2)
   maxDescriptionChars: 160
   dedupeSchemas: true
-  cachePath: .leanmcp/shrink-cache.json
+  cachePath: .tooltrim/shrink-cache.json
 
 inbound:
   stdio: true
@@ -109,22 +109,22 @@ inbound:
     sessions: stateless          # stateless | redis://... (v0.2)
 
 observability:
-  trace:   { sink: file, path: .leanmcp/trace.ndjson }
+  trace:   { sink: file, path: .tooltrim/trace.ndjson }
   metrics: { prometheus: { enabled: true, port: 9464 } }
-  audit:   { enabled: true, path: .leanmcp/audit.ndjson }
+  audit:   { enabled: true, path: .tooltrim/audit.ndjson }
 ```
 
 `${VAR}` and `${VAR:-default}` are expanded from the environment in any string value.
 
 ### Config files
 
-`leanmcp` searches for one of these, walking up from the cwd:
+`tooltrim` searches for one of these, walking up from the cwd:
 
-- `leanmcp.config.yaml` / `.yml`
-- `leanmcp.config.json`
-- `leanmcp.config.js` / `.mjs`
-- `.leanmcp.yaml` / `.yml` / `.json`
-- a `"leanmcp"` key in `package.json`
+- `tooltrim.config.yaml` / `.yml`
+- `tooltrim.config.json`
+- `tooltrim.config.js` / `.mjs`
+- `.tooltrim.yaml` / `.yml` / `.json`
+- a `"tooltrim"` key in `package.json`
 
 You can also pass `--config <path>` to any command.
 
@@ -151,7 +151,7 @@ The default `rules` mode is fully deterministic:
 5. Truncate at the first sentence boundary past `maxDescriptionChars`.
 6. JSON-Schema dedup: any sub-tree that appears 2+ times is hoisted to `$defs` and replaced with `$ref`.
 
-Output is hashed and cached in `.leanmcp/shrink-cache.json`, so the same description always shrinks to the same bytes — your agent never sees a moving target.
+Output is hashed and cached in `.tooltrim/shrink-cache.json`, so the same description always shrinks to the same bytes — your agent never sees a moving target.
 
 The `llm` mode (v0.2) adds an optional offline pass that can be checked into git for reproducibility.
 
@@ -169,8 +169,8 @@ Every JSON-RPC frame in or out is one NDJSON line:
 ```
 
 ```bash
-leanmcp trace tail              # follow with pretty-printing
-leanmcp trace tail --no-pretty  # raw NDJSON, pipe to jq / Loki / Datadog
+tooltrim trace tail              # follow with pretty-printing
+tooltrim trace tail --no-pretty  # raw NDJSON, pipe to jq / Loki / Datadog
 ```
 
 ### Metrics
@@ -179,32 +179,32 @@ Prometheus endpoint at `http://<host>:9464/metrics`:
 
 | metric | type | labels |
 | --- | --- | --- |
-| `lean_mcp_calls_total` | counter | `upstream`, `tool`, `ok` |
-| `lean_mcp_call_duration_ms` | histogram | `upstream`, `tool`, `ok` |
-| `lean_mcp_tokens_saved` | gauge | `upstream` |
-| `lean_mcp_upstream_up` | gauge | `upstream` |
+| `tooltrim_calls_total` | counter | `upstream`, `tool`, `ok` |
+| `tooltrim_call_duration_ms` | histogram | `upstream`, `tool`, `ok` |
+| `tooltrim_tokens_saved` | gauge | `upstream` |
+| `tooltrim_upstream_up` | gauge | `upstream` |
 
 A starter Grafana dashboard is in [`examples/grafana-dashboard.json`](examples/grafana-dashboard.json).
 
 ### OpenTelemetry
 
-Set `OTEL_EXPORTER_OTLP_ENDPOINT` (or enable it in config) and LeanMCP initializes the Node SDK with an OTLP/HTTP trace exporter.
+Set `OTEL_EXPORTER_OTLP_ENDPOINT` (or enable it in config) and Tooltrim initializes the Node SDK with an OTLP/HTTP trace exporter.
 
 ### Audit
 
-Every `tools/call` lands in `.leanmcp/audit.ndjson` with the identity claims (`sub`, `iss`, `aud`, `scope`, `client_id`) decoded — but **not** verified — from the inbound `Authorization` Bearer token. Run a real auth gateway in front of LeanMCP if you need cryptographic verification.
+Every `tools/call` lands in `.tooltrim/audit.ndjson` with the identity claims (`sub`, `iss`, `aud`, `scope`, `client_id`) decoded — but **not** verified — from the inbound `Authorization` Bearer token. Run a real auth gateway in front of Tooltrim if you need cryptographic verification.
 
 ---
 
 ## CLI
 
 ```text
-leanmcp                       # start the proxy (default)
-leanmcp start                 # explicit
-leanmcp measure               # before/after token report; the README hero
-leanmcp validate-config       # parse + validate, no startup
-leanmcp validate-file <path>  # validate a JSON file against the schema
-leanmcp trace tail            # tail the NDJSON trace
+tooltrim                       # start the proxy (default)
+tooltrim start                 # explicit
+tooltrim measure               # before/after token report; the README hero
+tooltrim validate-config       # parse + validate, no startup
+tooltrim validate-file <path>  # validate a JSON file against the schema
+tooltrim trace tail            # tail the NDJSON trace
 ```
 
 All commands accept `-c, --config <path>`.

bench/README.md

@@ -1,6 +1,6 @@
-# LeanMCP enterprise benchmark
+# Tooltrim enterprise benchmark
 
-End-to-end harness that proves LeanMCP against five real MCP servers and
+End-to-end harness that proves Tooltrim against five real MCP servers and
 a real Claude Sonnet 4.5 agent loop. Output is `bench/REPORT.md`.
 
 ## Quick start
@@ -30,18 +30,18 @@ files are present.
 ## Docker (Linux, reproducible)
 
 The checked-in [`REPORT.md`](REPORT.md) hero numbers are produced with
-**`pnpm bench` inside the `leanmcp:dev` image** (linux-x64, Node 20) so the
+**`pnpm bench` inside the `tooltrim:dev` image** (linux-x64, Node 20) so the
 README and the report stay aligned regardless of your host OS.
 
 ```bash
-docker build -t leanmcp:dev .
+docker build -t tooltrim:dev .
 
 docker run --rm \
   -e GITHUB_TOKEN="$GITHUB_TOKEN" \
   -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
   -v "$(pwd)/bench/results:/app/bench/results" \
   -v "$(pwd)/bench:/app/bench" \
-  leanmcp:dev \
+  tooltrim:dev \
   pnpm bench
 ```
 
@@ -56,7 +56,7 @@ PowerShell: use `${PWD}\bench\...` for the volume paths. Full build/run notes:
 | `measure` | For 4 filter scenarios (raw / shrunk / common / task) records bytes + tokens of the merged tool list. | `bench/results/measure.json` |
 | `latency` | 100 samples each of `tools/list` and `tools/call (everything.echo)` direct vs through the proxy. | `bench/results/latency.json` |
 | `throughput` | 50 concurrent `tools/call` against the proxy, ops/sec + error count. | `bench/results/throughput.json` |
-| `agent` | Locked task run twice (direct fan-out vs LeanMCP), Claude Sonnet 4.5, capped at 8 turns × 1024 tokens. | `bench/results/agent{,-direct,-proxy}.json` |
+| `agent` | Locked task run twice (direct fan-out vs Tooltrim), Claude Sonnet 4.5, capped at 8 turns × 1024 tokens. | `bench/results/agent{,-direct,-proxy}.json` |
 | `report` | Stitches everything into `bench/REPORT.md`. | `bench/REPORT.md` |
 
 ## Flags

bench/REPORT.md

@@ -1,24 +1,24 @@
-# LeanMCP enterprise benchmark
+# Tooltrim enterprise benchmark
 
 > Five real MCP servers, one ~63-tool fan-out, a Claude Sonnet 4.5 agent loop,
-> and the same task run twice — once direct, once through `LeanMCP`.
+> and the same task run twice — once direct, once through `Tooltrim`.
 > Numbers below come from `pnpm bench`; raw JSON is in `bench/results/`.
 
 - Run timestamp: `2026-05-03T17:36:40.633Z`
 - Platform: `win32-x64`
 - Node: `v24.12.0`
-- LeanMCP: `v0.1`
+- Tooltrim: `v0.1`
 
 ## TL;DR
 
 - **Token diet**: 63 tools · 10,401 tokens of metadata at baseline → 3 tools · 656 tokens with the `task` filter. **93.7% reduction.**
 - **Proxy overhead**: `tools/call` p50 2.1 ms vs 0.3 ms direct (Δ +1.9 ms p50, +2.8 ms p95).
 - **Concurrency**: 50 parallel `tools/call` finished in 101 ms — **495 ops/sec, 0 errors**.
-- **Real LLM money**: same Claude Sonnet 4.5 task = 54,714 input tokens direct vs 12,690 through LeanMCP (**−42,024, 76.8% cheaper**).
+- **Real LLM money**: same Claude Sonnet 4.5 task = 54,714 input tokens direct vs 12,690 through Tooltrim (**−42,024, 76.8% cheaper**).
 
 ## 1. Setup under test
 
-Five MCP servers, all spawned over stdio, all reached through one `LeanMCP` Streamable HTTP inbound:
+Five MCP servers, all spawned over stdio, all reached through one `Tooltrim` Streamable HTTP inbound:
 
 | Upstream | Package | Server name | Version | Tools | Initialize ms |
 | --- | --- | --- | --- | --- | --- |
@@ -147,7 +147,7 @@ These three servers are listed first in the "Reference Servers" section of the R
 
 ## 6. Trace + metrics evidence
 
-Last 10 lines of `.leanmcp/trace.ndjson`:
+Last 10 lines of `.tooltrim/trace.ndjson`:
 
 ```ndjson
 {"level":"info","time":"2026-05-03T17:37:01.058Z","trace":true,"dir":"in","upstream":"everything","method":"tools/call","name":"everything.echo","ok":true,"durMs":22,"msg":"tools/call"}
@@ -165,17 +165,17 @@ Last 10 lines of `.leanmcp/trace.ndjson`:
 Live `/metrics` excerpt scraped during the throughput phase:
 
 ```text
-lean_mcp_calls_total{upstream="everything",tool="everything.echo",ok="true",service="leanmcp"} 51
-lean_mcp_call_duration_ms_bucket{le="25",service="leanmcp",upstream="everything",tool="everything.echo",ok="true"} 16
-lean_mcp_call_duration_ms_bucket{le="100",service="leanmcp",upstream="everything",tool="everything.echo",ok="true"} 51
-lean_mcp_call_duration_ms_bucket{le="250",service="leanmcp",upstream="everything",tool="everything.echo",ok="true"} 51
-lean_mcp_call_duration_ms_sum{service="leanmcp",upstream="everything",tool="everything.echo",ok="true"} 1629
-lean_mcp_call_duration_ms_count{service="leanmcp",upstream="everything",tool="everything.echo",ok="true"} 51
-lean_mcp_upstream_up{upstream="github",service="leanmcp"} 1
-lean_mcp_upstream_up{upstream="memory",service="leanmcp"} 1
-lean_mcp_upstream_up{upstream="sequentialthinking",service="leanmcp"} 1
-lean_mcp_upstream_up{upstream="everything",service="leanmcp"} 1
-lean_mcp_upstream_up{upstream="filesystem",service="leanmcp"} 1
+tooltrim_calls_total{upstream="everything",tool="everything.echo",ok="true",service="tooltrim"} 51
+tooltrim_call_duration_ms_bucket{le="25",service="tooltrim",upstream="everything",tool="everything.echo",ok="true"} 16
+tooltrim_call_duration_ms_bucket{le="100",service="tooltrim",upstream="everything",tool="everything.echo",ok="true"} 51
+tooltrim_call_duration_ms_bucket{le="250",service="tooltrim",upstream="everything",tool="everything.echo",ok="true"} 51
+tooltrim_call_duration_ms_sum{service="tooltrim",upstream="everything",tool="everything.echo",ok="true"} 1629
+tooltrim_call_duration_ms_count{service="tooltrim",upstream="everything",tool="everything.echo",ok="true"} 51
+tooltrim_upstream_up{upstream="github",service="tooltrim"} 1
+tooltrim_upstream_up{upstream="memory",service="tooltrim"} 1
+tooltrim_upstream_up{upstream="sequentialthinking",service="tooltrim"} 1
+tooltrim_upstream_up{upstream="everything",service="tooltrim"} 1
+tooltrim_upstream_up{upstream="filesystem",service="tooltrim"} 1
 ```
 
 > The trace.ndjson and `/metrics` endpoint are hot during the bench because `examples/benchmark.config.yaml` enables `observability.trace`, `observability.metrics.prometheus`, and `observability.audit`. They're real, not theoretical.