How do I install Repovine?

Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.

Does Repovine need an API key?

No required environment variable is listed on this record.

What transport does Repovine use?

Repovine runs locally over stdio.

When was Repovine last checked?

Last checked 2026-11-09. Checkout-local repository context graph over MCP; `npx repovine setup` wires skills, agents, hooks.

Repovine MCP server

Power your agent

Add this server

The publisher's own command. Not a PlugMCP endpoint.

Add to Cursor Add to VS Code Run on PlugMCP

Host a copy with our keys and logs.

Local command

npx -y [email protected]

Claude Code has no install link for a local command. Copy the command below and run it in a terminal.

shClaude Code

1claude mcp add io.github.legann-repovine -- npx -y repovine@0.1.1

Run in a terminal.

jsonClaude Desktop

1{2  "mcpServers": {3    "io.github.legann-repovine": {4      "command": "npx",5      "args": [6        "-y",7        "[email protected]"8      ]9    }10  }11}

claude_desktop_config.json

Local · npmPublisher installStep-by-step: add this in Claude

Remote URL or a command on your machine? How the two installs differ

Run on PlugMCP

Host a copy with our keys and logs.

A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.

Launch

Server facts

Local

Transport: stdio
Version: 0.1.1
Last checked

Tools

No tool list yet. Remote servers get one after the first health check.

FAQ

Questions

repovine

Repository context assembled and conveyed to coding agents.

The repository knowledge layer

A repository-agnostic core. Across supported languages, frameworks, and infrastructure formats, repovine normalizes repository structure into one queryable model.

Contract boundaries by design. The graph connects repository units through shared code, template, and runtime contracts. These boundaries support repository-scale navigation, dependency impact, runtime flow, and configuration.

Versioned knowledge with explicit ownership. Version-controlled annotations attach intent, invariants, risks, and operational knowledge to graph nodes. Agents and developers author them; repovine checks freshness and structural consistency against repository state.

Together, these layers support intent-driven, context-compiled, contract-verified development. Task intent guides MCP context assembly, and observable claims are checked against repository state.

Checkout-local by design. The live graph and indexes are built from each checkout's working tree and run in memory. Configuration and authored knowledge travel through Git. No database is required.

Benchmarks. Across correctness and restraint tasks drawn from public software repositories, 90% of Repovine runs passed their case-specific diff gate, compared with 10.6% of baseline runs. Explore the results.

Quick start

Start in an existing repository:

npx repovine setup claude # or codex, cursor, all

setup connects the selected client to repovine, adds repovine skills, hooks, and instructions, and builds the repository graph.

The graph model

repovine deterministically derives a graph of cross-unit contracts from repository state. Source and infrastructure plugins translate stack-specific structures into the same vocabulary of packages, modules, exported symbols, templates, runtime resources, and their relationships—so navigation, dependency impact, runtime flow, and configuration work consistently across supported stacks. Explore the design rationale.

How it works

The engine and MCP provide the base workflow. Interactive clients use it directly. For explicit protocol runs, Delivery Protocol adds a structured assignment → result → compliance contract around the same workflow.

Client

In clients such as Claude Code, Codex, or Cursor, the agent uses repovine MCP directly while the developer stays in the loop.

graph LR
  SRC["sources"] --> S1["Stage 1: gather facts"]
  S1 --> S2["Stage 2: build graph"]
  S2 --> ANN["versioned annotations on graph nodes"]
  A["agents and developers"] --> ANN
  S2 --> S3["Stage 3: build search index"]
  ANN --> S3
  S3 --> MCP["MCP tools"]
  ANN --> MCP
  MCP -->|"bounded context"| C["Cursor, Claude Code, or Codex"]

Stage	Input	Output
Stage 1: gather facts	sources	exports, imports, env names, routes, infra
Stage 2: build graph	facts	packages → modules → symbols; infra/template/domain edges
annotations	graph + agent/developer writes	versioned intent, invariants, risks, side effects, and operational constraints
Stage 3: build search index	graph + annotations	token index; optional embeddings to assist fuzzy search
MCP	graph + annotations + index	bounded graph and annotation query results

Delivery Protocol

Delivery Protocol defines the assignment → structured result → compliance report contract. Core owns the schemas, projections, and validators that ground the protocol in observable repository state.

The agent uses MCP to access repository context while it works. The repovine CLI validates the assignment and result and produces the compliance report.

graph LR
  IN["assignment"] --> AV["assignment validation"]
  AV --> A["agent"]
  A <-->|"repository context during the run"| MCP["repovine MCP"]
  A --> R["structured result"]
  AV -->|"validated assignment"| V["repovine compliance validation"]
  R --> V
  S["observable repository state + recorded context"] --> V
  V --> OUT["compliance report"]

repovine validates schema conformance, assignment linkage, and claims it can recompute from the graph, annotations, recorded MCP context, and an optional revision delta. The compliance report covers protocol conformance and repository grounding; behavioral correctness and merge readiness are outside the protocol's scope.

The runnable LangGraph harness demo applies the protocol in an end-to-end agent workflow. Its orchestration topology, sandbox, retries, worktree isolation, and provider behavior are demo-specific implementation choices. See the Delivery Protocol integration guide.

MCP tools

Each tool returns a scoped, structured response.

Query tools, with typical questions for a large repository:

Group	Example question	Tools
Navigate	where is authentication? what is inside the billing package?	`search_context`, `map_context`, `inspect_node`
Runtime	what are the entrypoints? how does an order flow through services?	`get_entrypoints`, `trace_flow`
Contracts & config	which consumers are affected by an API change? which environment variables does the worker read?	`analyze_dependencies`, `get_config_surface`
Architecture	are there boundary violations or god modules?	`analyze_architecture`

Maintenance tools service the graph and annotations:

Group	Purpose	Tools
Memory	which nodes are annotated or stale?	`get_annotation_status`, `write_annotation`, `merge_annotations`, `validate_annotations`, `get_annotation_merge_status`
Sync	rebuild and check the graph	`refresh_context`, `get_build_status`, `get_context_session_quality`
Domains	tune the domain config	`suggest_domains_config`
Declines	dismiss reviewed advisory items	`decline_advisory` (kind: `domains-config` \| `carrier-link-gaps`)

Setup and CLI

setup adds the following repovine integrations to the workspace while preserving existing configuration and project specialists:

Integration	Included
MCP server	the repovine MCP tools
Skills	`repovine-workflow`, `repovine-annotations`, `repovine-refresh`, `repovine-review`, `repovine-status`
Subagents	`repovine-repo-explorer`, `repovine-annotation-writer`, `repovine-architecture-auditor`, `repovine-code-reviewer`
Hooks	pre-edit boundary notice, post-edit stale-graph notice, session-start "MCP first" reminder
Instructions	`AGENTS.md` (Cursor uses `.cursor/rules`)

Command	Goal
`npx repovine`	run the stdio MCP server outside an IDE/CLI client
`npx repovine setup cursor` (or `claude`/`codex`/`all`)	add the integrations above, then build the graph
`npx repovine build`	build the graph
`npx repovine status`	graph / config / annotation health
`npx repovine doctor`	diagnose the workspace integration
`npx repovine clear`	remove repovine-managed workspace files
`npx repovine --version` · `--help`	version / help
`npx repovine delivery --help`	harness/CI Delivery Protocol commands: descriptor, manifests, run brief, validation, and compliance
`npx repovine agents --help`	harness/CI utilities for repository roles, deterministic orientation, and context-session quality

STDIO is the only supported MCP transport in v1. For remote, devcontainer, WSL, VM, or devbox use, launch the repovine subprocess inside that environment so it runs in the checkout being analyzed.

Supported stacks

Area	Support
Languages	First-class support: TypeScript (JS/JSX via the TS toolchain, needs `tsconfig.json`); Python partial (backend routes + server-rendered templates)
Frameworks	React, Next.js, Nuxt, SvelteKit, Angular, NestJS, serverless monorepos; Vue/Svelte single-file components (script blocks only)
IaC	Partial, expanding coverage: SAM/CloudFormation, Terraform, Kubernetes, Helm, Dockerfile, docker-compose, Vercel

IaC parsers turn infra files into runtime-resource nodes plus links to the code and images behind them. They cover selected resources and relationships rather than complete format schemas. Coverage is under active development, and extending the existing extractors is a contribution area. Design detail: DESIGN.md.

Requires Node.js 22+ and one indexable root: tsconfig.json, pyproject.toml/setup.py (needs python3), or IaC files. Repositories with supported IaC files can be indexed without a source project; the graph contains infrastructure modules and runtime resources, but no code modules.

Repository files

File / dir	Git	Role
`repovine.config.json`	commit	main config: graph build and MCP output
`repovine.domains.json`	commit	logical organization of the repository graph
`repovine.annots.json`	commit	semantic annotation memory
`.repovine/`	ignore	local engine cache and workspace state

Defaults work for most TypeScript repositories. Config reference: docs/workspace-files.md.

Status

Preview (0.1.0), usable today and open to contributions. The graph schema and @repovine/plugin-sdk still change.

Contribute

repovine's plugin architecture provides two public producer surfaces for extending language and infrastructure coverage, both exposed by @repovine/plugin-sdk:

Plugin	What it adds
Language source producer	a language: source files → modules, imports, exports, semantic hints
IaC parser	an infra format: files → runtime-resource nodes and links

Built-in and third-party producers share the same public plugin contracts; core validates their output and owns graph identities and ontology. See the plugin guide and runnable Go source plugin, IaC plugin, and other examples.

Learn more

DESIGN.md: system boundaries, graph contract, trust model, and limitations
CONTRIBUTING.md: dev setup, quality gates
Documentation: guides, references, and the TODO app walkthrough
Platform support: per-surface OS tiers, prerequisites, and promotion rules
examples: runnable plugins and the Delivery Protocol harness demo

License

MIT. See LICENSE.

Add this server

Host a copy with our keys and logs.

Server facts

Tools

Questions

How do I install Repovine?

Does Repovine need an API key?

What transport does Repovine use?

When was Repovine last checked?

Documentation

repovine

The repository knowledge layer

Quick start

The graph model

How it works

Client

Delivery Protocol

MCP tools

Setup and CLI

Supported stacks

Repository files

Status

Contribute

Learn more

License