Trove·v0.2

Trove.

Higher information density, not larger prompts.

Trove makes LLMs operate over repositories far larger than their context window. The Rust engine indexes symbols, modules, and architecture into .trove/. The Claude Code plugin captures decisions, gotchas, and conventions in a personal trove that reloads every session.

Try the engine Install plugin v0.2.0 release

01 Engine

Index any repository

The Trove engine parses your codebase into a memory hierarchy: symbols, per-file module summaries, subsystem clusters, and an architecture map. Retrieval flows top-down and stops when it has enough detail.

# requires Rust
git clone https://github.com/anishfyi/trove && cd trove
cargo build -p trove-cli
cargo run -p trove-cli -- index
cargo run -p trove-cli -- query "modify vendor onboarding"

L1-L4

Memory layers

Symbols, modules, subsystems, architecture. Hash-tracked, incremental rebuilds. Output in .trove/ (gitignored).

RETRIEVE

Progressive context

Query with natural language. Get architecture first, then drill into modules and symbols only if needed. Respects a context budget.

See VISION.md for the full L0-L6 design.

02 Plugin

Add it to Claude Code

Run these one at a time inside Claude Code, top to bottom.

1
Add the marketplace
```
/plugin marketplace add anishfyi/trove
```
A marketplace is just a Git repo that lists installable plugins. This points Claude Code at Trove's repo so it knows where to fetch the plugin from. Nothing is installed yet.

Hit an SSH Permission denied (publickey) error? You have no SSH key on GitHub, so use the HTTPS URL instead: /plugin marketplace add https://github.com/anishfyi/trove.git
2
Install the plugin
```
/plugin install trove@anishfyi-trove
```
Pulls the Trove plugin from that marketplace: five skills (init, remember, recall, index, query) plus SessionStart and SessionEnd hooks. Read it as plugin@marketplace, so trove is the plugin and anishfyi-trove is the marketplace you just added.
3
Reload so it activates
```
/reload-plugins
```
A freshly installed plugin is not live until you reload. This activates Trove's skills and hook in your current session. Confirm it landed with /plugin list, and type /trove: to see the new commands appear. The auto-load hook starts firing from your next new session onward.
4
Create your trove
```
/trove:init
```
Scaffolds your trove at ~/.claude/trove (or per project): an INDEX.md and an entries/ folder. That is the whole setup. From here, say "remember this" or run /trove:remember to capture a fact, and /trove:recall to search it back.

# skills only (no auto-load hook)
git clone https://github.com/anishfyi/trove /tmp/trove
cp -r /tmp/trove/plugins/trove/skills/* ~/.claude/skills/

Copies the three skills into ~/.claude/skills/ so you get /init, /remember and /recall. The automatic session-load hook only ships with the plugin install above.

03 How it works

Two layers, one system

ENGINE

Index `trove index`

Parses the repo into symbols, module summaries, subsystem clusters, and an architecture map. Stored in .trove/.

ENGINE

Query `trove query`

Progressive retrieval: architecture, then subsystem, module, symbol. Stops when enough context is assembled.

PLUGIN

Capture `/trove:remember`

Distills a decision, gotcha, or convention into one atomic entry and updates the index.

PLUGIN

Auto-load every session

SessionStart injects your personal trove index. SessionEnd prompts reflection and re-index reminders.

04 Why it matters

Why it speeds you up

Every Claude Code session normally starts from zero: you re-explain the codebase, the conventions, the decisions you already made. Trove ends that. What you teach it once it knows for good, so each session begins further ahead than the last.

It paces up your work

Stop re-explaining. Claude opens each session already aware of your decisions, conventions and gotchas. No daily "here is how this repo works" preamble.
Stop repeating mistakes. A footgun you hit once is written down, so Claude does not walk into it a second time.
Decide faster. Past decisions and their rationale are one recall away, so you do not re-litigate or contradict yourself.
Onboard instantly. A new machine, or a teammate on a project-scope trove, inherits all the accumulated knowledge at once.
Compounding returns. Teach it once, benefit every session after. The longer you use it, the more leverage it has.

Why the index is the engine

It is what loads every session. The INDEX.md (one compact line per entry) is injected into context at session start, so Claude knows everything it has without paying to load every full file.
It keeps recall fast and cheap. Claude scans the index, then opens only the handful of entries that matter, instead of dumping the whole trove into the prompt.
It is your map. Human-readable, skimmable and prunable, like a notebook's table of contents you can edit by hand.
Hooks make it findable. Each one-line entry is written to match intent, which is the difference between a pile of files and a memory you can actually use.

05 Anatomy of an entry

One fact, one file. Markdown or JSON.

Each entry is a single file, and Claude picks the format that fits what it is storing: Markdown for prose (decisions, gotchas, conventions) and JSON for structured context (mappings, lists of records, config, schemas). The index lists them side by side.

entries/use-pgx-not-orm.md prose → Markdown

---
title: Use pgx + sqlc, not a heavy ORM, in Go services
slug: use-pgx-not-orm
type: decision
created: 2026-06-13
tags: [go, postgres, data-layer]
---

We standardised on pgx for the driver and sqlc to generate
type-safe query code from plain SQL. GORM was rejected for
hiding query cost behind reflection.

**Why it matters:** reach for this on any new Go service.
**Related:** [[deploy-single-binary]]

entries/service-ports.json structured → JSON

{
  "title": "Local service ports",
  "slug": "service-ports",
  "type": "reference",
  "created": "2026-06-14",
  "tags": ["infra", "ports"],
  "summary": "which service runs on which port",
  "data": {
    "web": 8000,
    "trove-ui": 8010,
    "partners": 8011
  }
}

INDEX.md both, side by side

# Trove Index

- [Use pgx + sqlc, not a heavy ORM](entries/use-pgx-not-orm.md) - Go data-layer decision
- [Local service ports](entries/service-ports.json) - infra reference (JSON)
- [Staging DB mirrors prod nightly](entries/staging-db-mirror.md) - gotcha, do not seed

06 Commands

The whole surface

Command	What it does
`trove index`	Index the repo into memory layers (CLI).
`trove query`	Progressive retrieval with a context budget (CLI).
`/trove:init`	Create the personal trove (user or project scope).
`/trove:remember`	Capture a durable learning as a new entry.
`/trove:recall`	Search the trove and answer from it.
`/trove:index`	Index the repo via the engine (plugin skill).
`/trove:query`	Retrieve layered context before editing (plugin skill).
`SessionStart hook`	Loads the personal index into context each session.

The skills also auto-trigger on intent: say "remember this in my trove" or "what do I know about X" and the right skill fires without typing the command.

Index any repository

Memory layers

Progressive context

Add it to Claude Code

Add the marketplace

Install the plugin

Reload so it activates

Create your trove