- Role
- Personal project
- Status
- Private pre-release
- Release
- origin/main (private)
- Key outcome
- Repository packs and typed memory help agents restart with grounded context.
- Stack
- RustMCPAgent tooling
What it is
RepoLens scans a repository into structured, immutable
"packs," exposes that model through an Model Context Protocol — an open protocol that lets an AI agent discover and call external tools through one uniform interface, instead of bespoke per-tool glue. server, and pairs it with
a typed, decaying memory graph. The goal isn't to write code for the
agent — it's to stop every new session from starting cold. It is a
private pre-release; the snapshot it describes is named under
Evidence below.
The problem
Coding agents generate code well but lose project context the moment a session ends. Every new session restarts cold: re-grepping the same files, re-deriving the same conventions, re-making mistakes that were caught and rolled back weeks ago, guessing plausibly but wrongly because nothing pushes back. The naive fix — a bigger context window, more files dumped into the prompt — dilutes the signal in noise ("lost in the middle"). The bottleneck isn't intelligence; it's durable, structured perception.
Constraints & key decisions
Structured typed perception over a bigger prompt. Because cold-start re-discovery is the problem and dumping more files only dilutes the signal, RepoLens scans the repo into an immutable typed pack — files, symbols, dependency graph, profile — and exposes it through 26 MCP tools (code search, graph traversal, summaries, convention extraction, memory, wiki) instead of widening the context window. Cost: a pack is a build-and-refresh step, and because packs are immutable they go stale until the next scan.
Typed, decaying, Checking a remembered fact against the current code state, so knowledge that no longer holds can be flagged or dropped instead of trusted blindly. memory over a flat store. A flat Retrieval-Augmented Generation — pulling relevant text from a store and feeding it to the model at query time. The plain version tracks no staleness or trust, so rolled-back facts can resurface. bucket has no notion of staleness or trust, so agents re-make rolled-back mistakes. Memory here is a typed graph (five node types) with exponential decay and a grounding status checked against the current pack — not a flat embedding store. Cost: more moving parts, and recall is decay-based and grounded, not a source of truth — it can be stale or wrong by design.
Publish the calibrated status before the surface is
complete. Agent tooling is full of inflated claims, and a
tool that overstates erodes the very trust it exists to build. So the
shipped boundaries are labeled out loud: validate-plan is
warnings-only (a clean run doesn't prove a plan valid),
remember is workspace-markdown handoff — not the typed
graph, eval is scaffolding (it launches no agents and
grades nothing; a human fills the scorecard), and state
is read-only inspection. Cost: the page reads less
impressive than a vaguer one would, because the gaps are stated
instead of glossed.
A regression-locked benchmark over "more context must be better." Whether an agent's context is actually improving has no answer without a measurement, so RepoLens emits calibrated evidence findings (agent-readable) and keeps a five-case eval contract with one case regression-locked. Cost: the contract is a maintenance burden, and the eval is scaffolding — humans grade it; it isn't automated proof.
Evidence
A private working snapshot of origin/main — there is no
public source, crate, or docs page to inspect. What backs the claims
instead is the running surface: scan, init,
brief --task, remember --file,
eval list / start, validate-plan --file,
state, compare-summaries, and
findings are usable today through the CLI and MCP,
alongside the 26 MCP tools and the typed memory graph. The strongest
signal is the project's own honest-status discipline — a
published, per-surface map of what is shipped versus scaffolding, kept
deliberately calibrated so a future overclaim would stand out — and a
dogfood eval contract (five cases, one regression-locked)
that holds the line on context quality.
Next
The v0.1 milestone is what makes RepoLens legible as a product:
richer memory types — Hypothesis, Constraint,
FailedAttempt, FrictionFinding — and an
explicit Confidence enum (TestValidated /
HumanVerified / ScanExtracted /
AgentAsserted). Planned until they land in a public
release or public-main snapshot.
What it isn't
- Doesn't write code — agents do that.
- Not a replacement for tests or human review.
- Not a generic RAG store — memory is typed, grounded, and decays.
- Not multi-repo or org-wide memory today.
- No guarantee that recalled memory is correct.
- Private pre-release — not a public-source project today.