RepoQL — Give your agent senses

1,500 tok

to survey a thousand files — headlines, ranked by meaning

1 call

to read three method bodies across three files

format families parsed — TypeScript to Terraform to PDF

0 cloud

required — the index runs on your laptop, beside your IDE

One index, four senses

Feel the shape of a codebase without opening a file

Every file is pre-parsed into three levels — a one-line headline, its structure, its content. Agents spend tokens only on what matters.

explore

Hear relevance

Hybrid lexical + semantic search over everything. The landscape, ranked by meaning — before committing to read anything.

read

Reach precisely

A single method body. A line range. A glob across every file. Progressive detail that honors a token budget exactly.

query

See relationships

SQL over the whole graph — code, git history, parsed data files. What calls what; what depends on what.

explain

Ask the index

A synthesized answer with citations, drawn from up to 50k tokens of source the agent never had to hold.

Progressive disclosure

Same address, three depths

Every file is pre-computed at three levels — a one-line headline, its structure, its full content. The token budget decides which one you get; the address never changes.

An agent scans a thousand headlines to know what exists, narrows to twenty structures to see the shape, and reads three bodies to understand — never opening a file it didn't need.

Try the tabs. Same file, three bets.

// read("file:///src/…/Modules/Git/GitModule.cs", 40) GitModule — on-demand git via LibGit2Sharp: status, diff, blame, patches. No pre-indexing. | 550 ln

// read("… => structure", 320) GitModule : DatabaseModule +TableFunction git_status(repo_uri) +TableFunction git_diff(repo_uri, from_ref, to_ref) +TableFunction git_blame(uri, line_from, line_to) +TableFunction git_patches(uri, max_count) -Repository OpenRepository(RepoUri uri) -string ResolveWorkTree(string physicalPath)

// read("…#symbol=git_blame => content", 800) [TableFunction("git_blame")] public IEnumerable<BlameRow> GitBlame(string uri, long from, long to) { var physical = _resolver.Resolve(RepoUri.Parse(uri)); using var repo = OpenRepository(physical); var hunks = repo.Blame(physical.RelativePath, new BlameOptions { MinLine = (int)from, MaxLine = (int)to }); // one row per hunk — commit, author, when, lines …

What the agent sees

Thirty grep calls, or one address

Everything is addressable. Files, symbols, line ranges, globs — one URI scheme across your repo, imported repos, and the docs themselves.

Ask for every Service member's signature across the codebase and the index answers from what it already knows — nothing is opened, nothing is wasted.

The risk is asymmetric. A bad query costs 1,500 tokens. A good one saves 50,000.

// one call — every filesystem implementation's signatures read("file:///src/**/*.cs#symbol=*FileSystem => structure", 3000) // the index answers in 0.3s, exactly 3,000 tokens PhysicalFileSystem : IFileSystem +Task<Stream> OpenRead(RepoUri uri) +IAsyncEnumerable<FileEntry> Enumerate(GlobSpec spec) GitTreeFileSystem : IFileSystem +Task<Stream> OpenRead(RepoUri uri) · 14 more

Works where your agent works

MCP, CLI, gRPC — same index, any surface

One long-lived host per machine. Agents connect and disconnect freely; the index is always warm.

mcp Claude Code mcp Codex mcp Cursor cli rql query · read · explore grpc your own tools sql DuckDB surface

22 format families

It reads what your repo is made of

Code, data, documents — parsed to symbols and structure, not just text. Even the PDFs.

TypeScriptPythonGoRustC++.NETRubyPHPSQLJSONYAMLMarkdownMermaidGraphQLTerraformCSSCSVMakeProtoPDFDOCXXLSX