convez.ai
SkillProdutividadeIntermediário
anishfyi

Trove - Índice de Memória Pessoal para Claude Code

anishfyi/trove

Memória persistente baseada em arquivos para acelerar fluxos de Claude Code

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill que constrói e mantém uma camada semântica baseada em arquivos, armazenando decisões, convenções, gotchas e referências do seu trabalho. Recarrega automaticamente a cada sessão, eliminando a necessidade de re-explicar contextos. Portável, pesquisável e sem dependências externas.

Instalação

$npx convez-ai anishfyi/trove

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 3 semanas
Versão
v0.2.0
Issues abertas
15
Contribuidores
1

Casos de uso

  • Manter registro de decisões arquiteturais e rationale do projeto
  • Documentar convenções, padrões e gotchas específicos do codebase
  • Eliminar re-explicações de contexto entre sessões do Claude Code
  • Criar referências estruturadas (configs, schemas, mappings) em JSON

Veredito

Ferramenta prática que resolve um problema real: perda de contexto entre sessões. Implementação limpa baseada em arquivos, sem lock-in. Ideal para projetos que exigem memória acumulada, especialmente equipes ou work-in-progress de longa duração.

README

A tradução para o português deste README ainda está na fila.

Trove - a personal memory index for Claude Code

Install once, and Claude Code keeps a personal, file-based trove of your decisions, gotchas, conventions and references as you work, and reloads it into context at the start of every session.

Live page: https://anishfyi.github.io/trove/

Every fact is one file, and Claude picks the format that fits it: Markdown for prose (decisions, gotchas, conventions) or JSON for structured context (mappings, lists, config, schemas). The trove is portable, greppable, diffable, and yours. No database, no service, no lock-in.


Install

Plugin (recommended)

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

1. Add the marketplace. A marketplace is just a Git repo that lists installable plugins. This points Claude Code at Trove's repo. Nothing is installed yet.

/plugin marketplace add anishfyi/trove

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. Pulls the Trove plugin (its three skills plus the SessionStart hook) from that marketplace. Read it as plugin@marketplace.

/plugin install trove@anishfyi-trove

3. Reload so it activates. A freshly installed plugin is not live until you reload. This activates the skills and hook in your current session (verify with /plugin list). The auto-load hook starts firing from your next new session onward.

/reload-plugins

4. Create your trove. Scaffolds ~/.claude/trove with an INDEX.md and an entries/ folder.

/trove:init

Done. From here, say "remember this" or run /trove:remember to capture, and /trove:recall to search it back.

Manual (skills only, no auto-load hook)

git clone https://github.com/anishfyi/trove /tmp/trove
cp -r /tmp/trove/plugins/trove/skills/* ~/.claude/skills/

This gives you /init, /remember, and /recall. The automatic session-load hook ships only with the plugin install above.


Usage

CommandWhat it does
/trove:initCreate the trove at user scope (~/.claude/trove) or project scope (./.claude/trove).
/trove:rememberDistill a durable learning into one atomic entry and add it to the index.
/trove:recallSearch the trove and answer grounded in the relevant entries.

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. Every new session, the SessionStart hook loads your INDEX.md into context so Claude starts aware of what it already knows.


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

The INDEX.md is the part that actually loads into context at session start, one compact line per entry, so Claude knows everything it has without paying to load every full file. Recall stays 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 also your human-readable map, skimmable and prunable like a notebook's table of contents, and each one-line hook is written to match intent. The index is the difference between a pile of files and a memory you can actually use.


What the trove looks like

Each entry is one file. Claude picks the format by the shape of the content: Markdown for prose, JSON for structured data. The index lists both, side by side.

~/.claude/trove/
├── INDEX.md                 # one line per entry, newest first
└── entries/
    ├── use-pgx-not-orm.md   # prose      -> Markdown
    ├── service-ports.json   # structured -> JSON
    └── staging-db-mirror.md

A Markdown entry (prose: decisions, gotchas, conventions):

---
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]]

A JSON entry (structured context: mappings, lists, config, schemas, the payload lives under data):

{
  "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 }
}

Both carry the same top-level fields (title, slug, type, created, tags). Entry type is one of: decision, gotcha, preference, reference, project, snippet.


What is worth remembering

Save: decisions and their rationale, gotchas and footguns, conventions you expect Claude to follow, external references (URLs, dashboards, tickets), and project constraints that are not obvious from the code.

Skip: secrets, transient task state, and anything trivially re-derivable from the codebase or git history. If a fact is one of those, capture what was non-obvious about it instead.


Repository layout

trove/
├── .claude-plugin/
│   └── marketplace.json          # lists the trove plugin
├── plugins/
│   └── trove/
│       ├── .claude-plugin/
│       │   └── plugin.json
│       ├── skills/
│       │   ├── init/SKILL.md
│       │   ├── remember/SKILL.md
│       │   └── recall/SKILL.md
│       ├── hooks/
│       │   └── hooks.json         # SessionStart: load the index
│       └── scripts/
│           ├── load-trove.sh      # hook body (read-only, defensive)
│           └── trove.sh           # tiny CLI helper (path/init/list/grep)
├── index.html                     # AlpineJS landing page
├── PRD.md                         # product requirements
├── ENGINEERING.md                 # engineering design
└── LICENSE

Docs


Built by anishfyi. MIT licensed.

Ver o original no GitHub

Bom para

Relacionados