Potencia tu agente
Instalación del publicador. No es un endpoint de PlugMCP.
Host a copy with our keys and logs.
Aún no hay una versión empaquetada en el registro. Sigue el README del repositorio.
¿URL remota o un comando en tu máquina? En qué se diferencian las dos instalaciones
Ejecutar en PlugMCP
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.
AbrirDel publicador
Agent-optimized git data for LLM agents. Five MCP tools that replace human-oriented
diffs with structured JSON -- function-level granularity, import tracking,
dependency changes, complete file snapshots, per-commit history, function
context (callers, callees, test references), and a one-call review_change
orchestration that combines manifest and function-context for PR review.
Agent-optimized git data MCP server — structured change manifests and full file snapshots for LLM agents
Git's porcelain output (diff, log, --stat) is designed for human eyes. When
an LLM agent parses a unified diff, it burns tokens on @@ hunk headers, +/-
line prefixes, and whitespace context that carries no semantic meaning. Worse, it
has to reconstruct what actually changed -- which functions were modified, which
imports were added, whether the file is generated -- from raw text.
git-prism gives agents structured data directly: a change manifest with per-file metadata and function-level analysis, plus full before/after file content when deeper inspection is needed.
cargo install git-prism
cargo install --path .
Grab a prebuilt binary from the GitHub Releases page.
brew tap mikelane/tap
brew install git-prism
Register git-prism as an MCP server for Claude Code:
claude mcp add git-prism -- git-prism serve
That's it. The server uses stdio transport and is available in all Claude Code sessions.
git-prism works through two independent mechanisms. They do different things and can be used together or separately:
If you only use the PATH shim (agents call git/gh directly and you
haven't registered git-prism as an MCP server), you don't need the MCP
registration at all -- and you can remove it to avoid the orphaned serve
processes described below.
If you use the MCP tools (get_change_manifest, etc.) in your agent
prompts, you need the MCP server registration.
Most users want both: the shim redirects raw git diff/git log calls,
and the MCP tools give structured data when the agent calls them explicitly.
git-prism serve is launched by the MCP client and its lifecycle is owned by
that client. In practice, Claude Code sessions sometimes exit without closing
the server's stdin, leaving an orphaned process running indefinitely. Observed
accumulation: 5+ processes, uptimes from ~2 hours to >1 day.
git-prism defends against this: the serve process polls its parent pid every
5 seconds and exits when it detects it has been reparented to init/launchd
(ppid == 1) -- the OS signal that the launching session has died.
If you are shim-only (no MCP tool calls in your prompts), removing the MCP registration entirely is the simplest fix:
claude mcp remove git-prism
Earlier versions bundled a Claude Code PreToolUse redirect hook, installed via
git-prism hooks install. It was removed in v0.9.0: the PATH shim
below is a strict superset of its coverage and the hook's structural blind spots
made it the weaker of the two. See
ADR 0010 and
ADR 0011 for the rationale.
git-prism hooks install now exits with an error directing you to
git-prism shim install. If you ran the old redirect hook, clean up its leftover
PreToolUse entry:
git-prism hooks uninstall # removes the legacy git-prism-bash-redirect-v1 settings.json entry
git-prism hooks status # reports whether a legacy entry remains, and at which scope
Install is Unix-only.
git-prism shim installcreates a symlink and relies on process-level interception; it cleanly bails on non-Unix platforms ("not supported on non-Unix platforms"). The passthrough code paths build and run on Windows (see #322), but the install flow itself assumes macOS or Linux.
A Claude Code PreToolUse hook only ever fires inside Claude Code's PreToolUse
pipeline. Agents that shell out to git through other channels — a subprocess,
a shell tool, a build script, a wrapper — never hit it. That blind spot is why
the bundled redirect hook was removed in favor of the PATH shim, which closes the
gap at the process level.
When installed, git-prism is placed on your PATH as a binary literally named
git, ahead of the real git. Every git invocation flows through git-prism
first. The shim then decides, per command:
diff, log, show, blame, and pickaxe forms
(-S/-G), but only when a ref range is present (e.g. git diff main..HEAD).git status or a bare git diff — falls straight through to the real git
binary, unchanged.Agent detection reuses the env-var-only logic behind
git-prism agent-detect: no agent signal (or CI=true)
means vanilla git, always. The classifier and watch list live in
src/shim/classify.rs; the real-git resolver that walks
PATH (skipping the shim's own directory) lives in src/shim/real_git.rs.
git-prism shim install
This creates a symlink at ~/.local/share/git-prism/bin/git pointing at the
git-prism binary and prints both the created path and the line to add to your
shell profile:
Created symlink: /home/you/.local/share/git-prism/bin/git
Add this to your shell init (~/.zshrc or ~/.bashrc):
export PATH="$HOME/.local/share/git-prism/bin:$PATH"
Add that export line to your shell profile so the shim directory precedes the
real git on PATH, then open a new shell.
To check status or remove the shim:
git-prism shim status # reports installed / not installed + directory
git-prism shim uninstall # removes the symlink
Deprecated:
git-prism hooks install --path-shimstill works in this release but prints a deprecation warning. Usegit-prism shim installinstead.
# 1. Install and wire up PATH
git-prism shim install
export PATH="$HOME/.local/share/git-prism/bin:$PATH"
# 2. As a non-agent, you get vanilla git — passthrough
git --version # prints the real git version
# 3. As an agent, a ref-range diff is intercepted and returns structured JSON
AI_AGENT=smoke-test git diff HEAD~1..HEAD | head -c 80
# => {"metadata":{ ... structured manifest ...
# 4. A ref-range-less command always passes through, even for an agent
AI_AGENT=smoke-test git status # plain porcelain
The shim sets GIT_PRISM_INSIDE_SHIM=1 in every child process it spawns. When
the shim sees that variable already set, it forces passthrough — so nested git
calls (a lefthook pre-push hook, cargo's internal git, a build script that
shells out to git) never recurse back into the shim and loop. You can set it
yourself to force vanilla git for one command:
GIT_PRISM_INSIDE_SHIM=1 git diff main..HEAD # bypasses the shim
GIT_PRISM_PASSTHROUGH)Set GIT_PRISM_PASSTHROUGH=1 (or the alias GIT_PRISM_DISABLE=1) to make the
shim exec the real git/gh immediately — before telemetry init, before
classification, with near-zero added latency:
GIT_PRISM_PASSTHROUGH=1 git diff main..HEAD # real git, no shim overhead
This is the first-class alternative to putting /usr/bin ahead of the shim on
PATH. Use it to wrap a test suite or tight loop where shim processing and
telemetry are not desirable:
GIT_PRISM_PASSTHROUGH=1 cargo test # git calls inside tests skip the shim
Accepted truthy values: 1, true (case-insensitive). Any other value (or
unset) leaves the shim active.
Set GIT_PRISM_DEBUG_RESOLVER=1 to print the resolved real-git path to stderr,
so you can confirm which git binary the shim is delegating to:
GIT_PRISM_DEBUG_RESOLVER=1 git status
# (stderr) git-prism shim: resolved real git to /usr/bin/git
If you use rtk (or any tool that also wraps git
on PATH), the two wrappers will fight over the same command. Tell rtk to leave
git alone by adding it to rtk's exclude list in
~/Library/Application Support/rtk/config.toml:
exclude_commands = ["git"]
git-prism hooks uninstall --path-shim # removes the symlink
git-prism hooks status # reflects path-shim presence/absence
After uninstalling, remove the export PATH=... line you added to your shell
profile.
A narrated end-to-end walkthrough of the shim lives at
demo/path-shim.mp4.
git-prism agent-detect
Prints a JSON object indicating whether the current process is running on behalf of an AI coding agent, detected via environment variables only.
{ "agent": "ClaudeCode", "signal": "ToolSpecific" }
Both fields are null when no agent is detected, or when CI=true is set (CI
wins over all agent signals).
Detection priority order:
AI_AGENT non-empty (Vercel cross-tool convention, e.g. claude-code_2-1-141_agent) → signal: "AiAgent"AGENT set with an allowlisted value (goose, amp) → signal: "Agent". Bare AGENT=1 is intentionally ignored (collides with ssh-agent and build-system agents).CLAUDECODE, CURSOR_AGENT, GEMINI_CLI, CODEX_SANDBOX, CLINE_ACTIVE, AUGMENT_AGENT, OPENCODE_CLIENT, TRAE_AI_SHELL_ID → signal: "ToolSpecific"CI set → {"agent": null, "signal": null} regardless of any agent markers above.This subcommand is a diagnostics/ops tool. It is not exposed as an MCP tool — it does not appear in the MCP tool registry and existing tools are unaffected.
get_change_manifestReturns structured metadata about what changed between two git refs.
Parameters:
Example output:
{
"metadata": {
"repo_path": "/home/user/myproject",
"base_ref": "main",
"head_ref": "HEAD",
"base_sha": "a1b2c3d4e5f6",
"head_sha": "f6e5d4c3b2a1",
"generated_at": "2026-04-03T12:00:00Z",
"version": "x.y.z"
},
"summary": {
"total_files_changed": 3,
"files_added": 1,
"files_modified": 2,
"files_deleted": 0,
"files_renamed": 0,
"total_lines_added": 47,
"total_lines_removed": 12,
"total_functions_changed": 4,
"languages_affected": ["go", "rust"]
},
"files": [
{
"path": "src/handler.go",
"old_path": null,
"change_type": "modified",
"change_scope": "committed",
"language": "go",
"is_binary": false,
"is_generated": false,
"lines_added": 25,
"lines_removed": 8,
"size_before": 1200,
"size_after": 1450,
"functions_changed": [
{
"name": "HandleRequest",
"old_name": null,
"change_type": "signature_changed",
"start_line": 15,
"end_line": 42,
"signature": "func HandleRequest(ctx context.Context, req *Request) (*Response, error)"
},
{
"name": "validateInput",
"old_name": "checkInput",
"change_type": "renamed",
"start_line": 44,
"end_line": 58,
"signature": "func validateInput(req *Request) error"
}
],
"imports_changed": {
"added": ["context", "errors"],
"removed": ["log"]
}
}
],
"dependency_changes": [
{
"file": "go.mod",
"added": [{"name": "github.com/pkg/errors", "old_version": null, "new_version": "v0.9.1"}],
"removed": [],
"changed": []
}
],
"pagination": {
"total_items": 3,
"page_start": 0,
"page_size": 100,
"next_cursor": null
}
}
get_file_snapshotsReturns complete before/after file content at two git refs. No diffs to parse -- the agent gets the full file at each point in time.
Parameters:
Example output:
{
"metadata": {
"repo_path": "/home/user/myproject",
"base_ref": "main",
"head_ref": "HEAD",
"generated_at": "2026-04-03T12:00:00Z"
},
"files": [
{
"path": "src/handler.go",
"language": "go",
"is_binary": false,
"before": {
"content": "package main\n\nfunc HandleRequest(req *Request) error {\n // old implementation\n}\n",
"line_count": 5,
"size_bytes": 82,
"truncated": false
},
"after": {
"content": "package main\n\nimport \"context\"\n\nfunc HandleRequest(ctx context.Context, req *Request) (*Response, error) {\n // new implementation\n}\n",
"line_count": 7,
"size_bytes": 130,
"truncated": false
},
"error": null
}
],
"token_estimate": 53
}
get_commit_historyReturns one manifest per commit in a range, so agents can see what changed in each commit separately instead of a single collapsed diff.
Parameters:
Example output:
{
"commits": [
{
"metadata": {
"sha": "a1b2c3d4",
"message": "add validation helper",
"author": "Jane Dev",
"timestamp": "2026-04-03T10:30:00+00:00"
},
"files": [
{
"path": "src/validate.rs",
"change_type": "added",
"language": "rust",
"lines_added": 25,
"lines_removed": 0
}
],
"summary": {
"total_files_changed": 1,
"files_added": 1,
"total_lines_added": 25,
"total_lines_removed": 0
}
}
],
"pagination": {
"total_items": 1,
"page_start": 0,
"page_size": 100,
"next_cursor": null
}
}
get_function_contextReturns callers, callees, and test references for each function that changed between two refs. Answers "what calls this function?" and "what does this function call?" without the agent having to grep.
Uses import-aware scoping for Rust, Python, Go, and TypeScript/JavaScript to filter the caller scan to files that actually import the changed module. This eliminates false positives from leaf-name collisions and improves performance on large repos. Unsupported languages fall back to full-repo scanning.
Parameters:
Example output:
{
"metadata": {
"base_ref": "HEAD~1",
"head_ref": "HEAD",
"base_sha": "a1b2c3d4",
"head_sha": "f6e5d4c3",
"generated_at": "2026-04-09T12:00:00Z"
},
"functions": [
{
"name": "validate_input",
"file": "src/validation.rs",
"change_type": "modified",
"blast_radius": {
"production_callers": 1,
"test_callers": 1,
"has_tests": true,
"risk": "low"
},
"scoping_mode": "scoped",
"callers": [
{ "file": "src/handler.rs", "line": 42, "caller": "handle_request", "is_test": false }
],
"callees": [
{ "callee": "check_length", "line": 15 },
{ "callee": "check_format", "line": 18 }
],
"test_references": [
{ "file": "tests/test_validation.rs", "line": 10, "caller": "test_validate_empty", "is_test": true }
],
"caller_count": 2
}
]
}
The scoping_mode field indicates how the caller scan was performed: "scoped"
means import-based filtering was used (more precise but may miss callers that
use unusual import patterns), while "fallback" means the scan parsed every
file in the repo (authoritative but slower). Use this to decide whether a
zero-caller result is definitive or potentially incomplete.
review_changeReturns combined change manifest and function-level blast radius for a ref
range, in one call. Use this instead of git diff <ref>..<ref> when
reviewing a PR, auditing a refactor, or assessing merge safety -- it answers
"what changed and what might break" in one tool invocation, with structured
JSON instead of raw diff text.
Replaces the common two-step workflow (get_change_manifest then
get_function_context) with a single call that runs both internally and splits
the response-size budget 40/60 (manifest / function_context).
Parameters:
The two cursors are independent so an agent can advance one half (e.g., walk
through a long file list) without re-paginating the other. Each sub-response
carries its share of the budget in metadata.budget_tokens so downstream
observability can audit the split decision.
Example output:
{
"manifest": {
"metadata": {
"base_ref": "HEAD~1",
"head_ref": "HEAD",
"budget_tokens": 1638,
"...": "..."
},
"summary": { "total_files_changed": 3, "...": "..." },
"files": [{ "path": "src/lib.rs", "...": "..." }],
"pagination": { "next_cursor": null, "...": "..." }
},
"function_context": {
"metadata": {
"base_ref": "HEAD~1",
"head_ref": "HEAD",
"budget_tokens": 2458,
"...": "..."
},
"functions": [{ "name": "validate", "blast_radius": { "risk": "medium" }, "...": "..." }],
"pagination": { "next_cursor": null, "...": "..." }
}
}
git-prism also works as a standalone CLI for scripting and debugging:
# Change manifest between two refs
git-prism manifest HEAD~1..HEAD
# Manifest for a specific repo path
git-prism manifest main..feature-branch --repo /path/to/repo
# Per-commit history for a range
git-prism history HEAD~5..HEAD
# Smaller pages for constrained environments
git-prism manifest main..HEAD --page-size 50
# File snapshots for specific paths
git-prism snapshot HEAD~3..HEAD --paths src/main.rs src/lib.rs
# Function context (callers, callees, test references)
git-prism context HEAD~1..HEAD
# List supported languages
git-prism languages
The manifest, snapshot, history, and context commands output JSON to
stdout. The manifest and history commands auto-paginate internally (default
page size 500, configurable with --page-size) and always return the complete
result. The languages command outputs plain text.
For PR review, refactor audits, or any "what changed and what might break" question,
use review_change instead of git diff:
review_change(base_ref="main", head_ref="HEAD")
This returns a combined { manifest, function_context } payload in one call, splitting
the token budget 40/60 between the two halves. It replaces the two-step manifest +
function_context workflow when you need both in the same session.
When you need finer control -- different budgets per half, filtering by function name, or deep-diving into specific files -- use the individual tools in order:
Step 1: Triage with get_change_manifest
Ask for the manifest to understand the shape of a change. The summary tells you file counts, line counts, and affected languages. The per-file entries tell you which functions changed signatures, which imports were added, and whether files are generated (safe to skip).
Step 2: Blast radius with get_function_context
For the changed functions identified in step 1, request function context. This
tells you which other files call each changed function, what each changed
function calls, and which test files reference it. Each function includes a
blast_radius object with a risk level (none, low, medium, high)
computed from production caller count and test coverage -- sort by risk to
review the highest-impact changes first. The agent never has to grep through
the codebase to find callers or guess which tests to check.
Step 3: Deep dive with get_file_snapshots
Once you know which files and callers matter, request full snapshots of the
highest-impact files. You get complete before/after content -- no reconstructing
files from diff hunks. Use line_range to focus on specific sections and
include_before: false when you only need the current state. Pass
include_diff_hunks: true to get unified-diff hunk boundaries for computing
diff-relative line positions (e.g., for GitHub inline review comments).
Both paths keep token usage low. review_change is the most efficient starting
point for most review tasks; the three-call path is worth it when you need
targeted re-queries or want to page through a large manifest separately from
a large function list.
get_change_manifest and get_commit_history return a pagination object on
every response:
"pagination": {
"total_items": 842,
"page_start": 0,
"page_size": 100,
"next_cursor": "eyJvZmZzZXQiOjEwMCwiYmFzZV9zaGEiOiIuLi4ifQ=="
}
When next_cursor is non-null, pass it back as the cursor parameter on the
next call to fetch the following page. The cursor is an opaque base64 payload
that encodes the page offset plus the resolved base/head SHAs; the server
rejects a cursor whose SHAs no longer match the refs supplied in the follow-up
call, so a cursor minted against main..feature cannot be reused against a
different range. The manifest summary always reflects all files in the
changeset regardless of which page is returned, so agents can triage from
page 1 before deciding whether to page through the remaining file entries.
page_size is clamped server-side to the 1..=500 range; values outside that
range are coerced rather than rejected. The CLI (git-prism manifest,
git-prism history) paginates internally and always returns the complete
result; the cursor contract is only visible through the MCP tool interface.
Function-level analysis uses tree-sitter to extract functions, methods, imports, and call sites from source code.
Files in unsupported languages still appear in the manifest with full
line/size/change-type metadata -- functions_changed is null (not an empty
array) to distinguish "no grammar available" from "analyzed, nothing changed."
Function changes are detected by comparing SHA-256 hashes of function body content, not line positions. This means:
modified, even when line numbers don't shift.renamed
entry with old_name populated, instead of separate deleted + added.The change_type values for functions are: added, modified, deleted,
signature_changed, renamed. Renamed entries carry the previous name in
the old_name field (null for all other variants) so agents can correlate the
post-rename function back to its history.
Whitespace and comment sensitivity. The body hash is computed over the raw
byte span of the function body as tree-sitter sees it. Reformatting runs,
comment additions or removals, trailing-whitespace changes, and indentation
shifts will therefore change the hash and produce a modified entry even when
the executable logic is unchanged. A future release may normalize whitespace
and strip comments before hashing; until then, running a formatter on a file
will show every touched function as modified on the next manifest call.
git-prism parses dependency files and reports added, removed, and version-changed packages:
Cargo.toml (Rust)package.json (Node.js)go.mod (Go)pyproject.toml (Python, PEP 621)Optional OpenTelemetry instrumentation, disabled by default and opt-in via environment variables.
Quick start with Jaeger (any OTLP-compatible backend works):
docker run -d --name jaeger -p 4317:4317 -p 16686:16686 jaegertracing/all-in-one:latest
GIT_PRISM_OTLP_ENDPOINT=http://localhost:4317 git-prism serve
Privacy: No raw paths, file contents, author names, or ref names are exported. Paths are SHA-256 hashed; refs normalized to a bounded enum. See docs/telemetry.md.
See CONTRIBUTING.md.
Agent-optimized git data MCP server — structured change manifests and full file snapshots for LLM agents
Herramientas
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
Este registro no indica ninguna variable de entorno obligatoria.
Git Prism se ejecuta localmente por stdio.
Última comprobación: 2026-10-28. Agent-optimized git data MCP server — structured change manifests and full file snapshots for LLM agents
