SeleneCode Install

Local code intelligence for AI coding agents

Give your AI agent a map of your codebase.

SeleneCode turns your repository into a local code graph and makes it available to Claude Code, Cursor, Codex, and other MCP-compatible agents. Your agent can trace calls, find dependencies, explain architecture, and estimate the impact of a change without searching and reading dozens of files first.

$ curl -fsSL https://selenecode.com/install.sh | sh
Install SeleneCode View releases on GitHub
  • Local by default
  • One binary
  • No API key
  • No telemetry

Works with your coding agent

The problem

Coding agents waste context rediscovering your architecture.

Without a structural index, an agent has to search for a symbol, open several files, follow imports, identify callers, and reconstruct the execution path itself. It repeats that work in every new session. SeleneCode indexes those relationships once. The agent then asks the graph for the relevant source, the call path, and the affected code in a single request.

Without SeleneCode

  • Search for a symbol
  • Open multiple files
  • Follow imports by hand
  • Guess which callbacks are connected
  • Repeat when the first guess is wrong
  • Spend most of the context window gathering information

With SeleneCode

  • Ask one structural question
  • Get the relevant symbols and source locations
  • See the call path
  • Find callers and dependencies
  • Understand what a change could affect
  • Keep the agent's context focused on the actual task

What you can ask

Ask about the system, not the file tree.

❯ selene explore "how does an API request become a database write"

## Context for: how does an API request become a database write
Found 42 relevant symbols across 1,214 indexed files.

### Flow
1. handle_request    (src/api/routes.rs:88)
   ↓ calls
2. validate_payload  (src/api/guard.rs:41)
   ↓ dynamic: callback
3. Store::persist    (src/db/store.rs:203)

### Blast radius
Changing handle_request reaches 17 symbols across 6 files.

### Source — verbatim, line-numbered
…
Token economy: this answer ≈ 5k tokens; the 75 files it distills
total ≈ 237k tokens — 52× less than pulling them into context.

SeleneCode returns the path through the codebase, the relevant source locations, and the surrounding impact. Indirect connections such as callbacks, event handlers, and framework routes are part of the graph. A hop that crosses one is marked as dynamic, together with the mechanism that bridges it.

Questions you can ask

  • Where is authentication enforced?
  • What calls createInvoice?
  • What could break if I change UserService?
  • How does this request reach the database?
  • Which modules depend on the billing package?
  • Are there any import cycles?
  • Where is this environment variable used?
  • What changed structurally since the last release?

How it works

From repository to useful context in three steps.

1

Install the binary

One command per machine. Prebuilt for macOS, Linux, and Windows, checksum-verified. No Rust or Node toolchain needed.

2

Connect your project

Run selene install in the repository. It indexes the code, installs git hooks that keep the index current, and registers SeleneCode as an MCP server for your agent.

3

Ask normal questions

Restart your agent. When it needs structural context, it queries SeleneCode and receives focused results from the graph instead of reading the repository file by file.

Features

The context your coding agent is usually missing.

Trace execution paths

Follow a request or an operation across functions, modules, callbacks, and framework boundaries.

Understand change impact

Find callers, dependencies, and related symbols before modifying an important component.

Navigate architecture

See how packages, modules, entry points, and major components connect.

Find structural problems

Detect import cycles, disconnected modules, bottlenecks, and bridge components that carry more weight than they should.

Docs and config in the same graph

Markdown, reStructuredText, text, PDF, and Word documents are indexed with the code, and so are Dockerfiles, CI files, Makefiles, package manifests, Terraform, SQL schemas, and .env files. A document that names a symbol links to it; an environment key links to the code that reads it.

Compare revisions

selene diff shows how the code graph changed between Git revisions, without checking out the older revision.

Local first

Your source code stays on your machine.

SeleneCode ships as a single binary with an embedded database. Indexing and synchronization do not require a model, a server, an API key, or a network connection.

  • Local index The code graph is stored in your project, on your machine.
  • Deterministic extraction Structure comes from the source code's syntax tree, not from a model's summary.
  • Embedded database No separate database service to install or configure.
  • No API key required The standard indexing path never calls a model.
  • No telemetry Your code is not sent to SeleneCode or anyone else.
  • One binary Prebuilt releases need no Node or Rust toolchain.
12 languagesTypeScript, JavaScript, Python, Rust, Go, Java, Kotlin, C, C++, C#, PHP, and Ruby, parsed with native tree-sitter grammars.
One binaryThe indexer, the graph store, and the MCP server ship together.
No external servicesNo database server and no hosted backend. It works offline.

Visual exploration

See how your codebase fits together.

The SeleneCode galaxy view of this repository: its modules drawn as circles sized by symbol count and linked by the calls that cross between them, a legend of modules in the bottom-left panel, and the Galaxy, Systems, Logbook, Navigation and Mission views in the left rail.

selene viz renders an interactive, offline map of your architecture: modules sized by how much code they hold, the calls that cross between them, call-graph clusters, the most connected symbols, and the single edges that hold two modules together. Select a symbol to see its source and relationships.

Watch mode keeps the map current while an agent works: new functions and classes appear on the map seconds after they are written.

$ selene viz --open
$ selene viz --watch
  • Galaxy — the map: modules, symbols, clusters
  • Systems — domains and the flows that run through them
  • Logbook — configuration and documentation facts, grouped by kind
  • Navigation — the call path between two symbols
  • Mission — the guided tour, stop by stop

Optional

Turn the graph into an architecture guide.

selene enrich computes three more views from the graph. It needs no model and no API key, and selene enrich --clear removes everything it added.

Domains

Related code grouped into recognizable areas of the system.

Flows

How each entry point moves through the system, hop by hop.

Tour

A suggested reading order for an unfamiliar repository. selene tour prints it.

$ selene enrich
$ selene tour
$ selene enrich --clear

Install

Install it. Connect your agent. Start asking questions.

$ curl -fsSL https://selenecode.com/install.sh | sh
> irm https://selenecode.com/install.ps1 | iex
$ brew install mess69/selenecode/selene
> scoop bucket add selenecode https://github.com/Mess69/selenecode-releases scoop install selene

Already installed? selene upgrade updates in place. selene upgrade --check only reports.

Set up a project

From the repository you want your agent to understand, run one command. It indexes the project, installs git hooks that keep the index current, and registers SeleneCode as an MCP server for your agent. Restart the agent when it finishes.

$ selene install

Then ask something concrete

Ask your agent a question about structure and it answers from the graph.

  • What depends on UserService?
  • Show me how authentication works.
  • What will be affected if I change this function?

Stop making your coding agent rediscover the same codebase.

Install SeleneCode and give your agent the structural context it needs to make better changes. No server. No API key. No telemetry.

Install SeleneCode View releases on GitHub