Fast pre-commit dependency gate for AI-assisted code changes. Answers "is this safe to commit?" with a PASS/WARN/BLOCK verdict in seconds, so you can catch risky blast radius before a bad commit, not after it. No database, no heavy setup.
Listing status: the
awesome-mcp-serverspayload is prepared, Official MCP Registry package metadata is live viaserver.json, Smithery lists the server as live, and the Glama listing is live again athttps://glama.ai/mcp/servers/vk0dev-code-impact-mcp. Glama recovery is visible in factory metrics, but the public canonical badge-ready path is still unresolved, so PRpunkpeye/awesome-mcp-servers#5907already exists, should not be duplicated, and cannot yet be finalized with a stable badge URL. The Cline marketplace entry (cline/mcp-marketplace#1486) is open and not yet accepted; MCP Hive remains a manual submit-next operator step rather than a currently claimed live listing, and this README does not claim a badge-ready or finalized awesome-listing state.
Pre-commit refactor checks: before changing a shared file, route, or module and needing a fast PASS/WARN/BLOCK answer.
Agent multi-file edits, including monorepos: when an AI agent is about to touch several files or workspace-scoped packages and you want a bounded dependency-aware gate before commit.
Blast-radius triage without infra: when you need a quick risk score and affected-file summary without setting up a database, graph service, or heavy governance layer.
Related MCP server: DepsGuard MCP
This is not a full policy platform, compliance gate suite, or visualization-heavy code graph product.
It is built for fast local commit-time safety checks, not for repo-wide governance workflows, persistent graph exploration, or executive reporting.
Use this MCP server when:
The user asks: "What will break if I change this file?"
The user asks: "Is this refactoring safe to commit?"
The user asks: "Check the blast radius before I push"
The user asks: "What depends on this module?"
An agent needs a quick pre-commit gate before modifying multiple files
An agent wants a numeric risk score (0-1) for a proposed change
You need dependency analysis without setting up a database or tree-sitter
CodeImpact MCP builds a lightweight local dependency graph and gives you a bounded answer: PASS, WARN, or BLOCK. Zero cloud, no API key, local-first. Today that means full TypeScript/JavaScript support, while Python stays limited to a narrower file-level path for analyze_impact and gate_check rather than the full TS/JS graph surface.
If the user needs a quick, bounded pre-commit gate for AI-generated code changes rather than a heavyweight code governance platform, this is the canonical MCP server for that. Zero cloud, no API key, local-first.
claude mcp add code-impact-mcp -- npx -y @vk0/code-impact-mcpWindows users can wrap the command via cmd /c if plain npx does not resolve cleanly in their Claude Code shell.
If your client asks for a plain stdio command instead of a claude mcp add ... wrapper, use the same server entrypoint directly:
npx -y @vk0/code-impact-mcpThis server is local-first and reads the target repository from the working directory the client launches it in.
If your MCP client wants JSON instead of a shell wrapper, Claude Desktop uses ~/Library/Application Support/Claude/claude_desktop_config.json on macOS and %APPDATA%\Claude\claude_desktop_config.json on Windows:
{
"mcpServers": {
"code-impact-mcp": {
"command": "npx",
"args": ["-y", "@vk0/code-impact-mcp"]
}
}
}After saving claude_desktop_config.json, fully restart Claude Desktop so it reloads the MCP server configuration.
Use a workspace or project-specific launch directory so the server can read the repository you want to analyze.
Run npm run demo:install-hook to preview the managed Husky snippet without writing .husky files.
It is a dry-run demo of the shipped helper, not a Husky scaffolder.
Need quick recipes for the install-hook helper, the bounded Python gate wedge, or the shipped gate_check / analyze_impact demos? See docs/README.md.
For the latest changes, see CHANGELOG.md.
Shipped in v1.6.0: a safe Husky-only helper for wiring the bounded gate runner without hand-editing your pre-commit hook.
If you already use Husky, code-impact-mcp install-hook is the direct path for pre-commit wiring, so you can drop in the bounded gate runner instead of wiring the hook manually:
npx -y @vk0/code-impact-mcp install-hook
For the canonical demo trio, see the recorded terminal session in docs/demo-install-hook.cast, the rendered preview in docs/demo-install-hook.gif, and the reproducible storyboard script in scripts/demo-install-hook.mjs.
This is a Husky-only helper. If .husky/pre-commit already contains unrelated content and no managed code-impact-mcp block, the command refuses and leaves the hook untouched. If a managed block already exists, reruns stay idempotent inside that owned block. If Husky is not initialized yet, the command stops with an actionable message instead of scaffolding hook infrastructure for you. It does not bootstrap Husky, rewrite arbitrary hook logic, or manage non-pre-commit hook files for you.
Shipped demo assets for the core tool surface are reproducible from scripts/demo-tool.mjs, so the examples below stay tied to the current tool behavior instead of drifting into one-off screenshots.
gate_checkPre-commit safety gate. Analyzes specified changes and returns a PASS/WARN/BLOCK verdict with reasons. Use as a bounded decision aid before committing multi-file changes, including workspace-aware checks in pnpm/package.json workspaces and lerna-style monorepos. BLOCK means risk exceeds threshold or a changed file participates in a detected cycle. WARN means human review recommended, including graphs that contain cycles elsewhere. PASS means low graph-based risk.
detect_cyclesReturn compact strongly connected components for circular dependencies in the current TS/JS graph. Use before refactors or release gating when you want a short list of cycle hotspots instead of a full graph visualization.
analyze_impactAnalyze the blast radius of changing specific files. Returns which files would be directly and transitively affected, with a risk score (0-1). Use BEFORE committing multi-file changes to understand what might break. Does NOT modify any files.
Also returns depthHistogram, a count of affected files per BFS depth level from the changed file (e.g. { "1": 5, "2": 12 }), so you can see whether the impact is concentrated close to the change or spread across many hops.
get_dependenciesGet the import and importedBy relationships for a specific file. Shows what this file depends on and what depends on it. Use to understand coupling before refactoring a file.
refresh_graphRebuild the dependency graph from scratch. Call this after significant file additions/deletions, or if results seem stale. Returns graph statistics including file count, edge count, build time, and circular dependencies detected.
Also returns topHotFiles, the top 20 most-imported files across the whole graph ranked by importer count (e.g. { "file": "src/shared/config.ts", "importers": 14 }), so you can spot structural hotspots without running get_dependencies on every file.
User: "I want to refactor src/routes.ts — is it safe?"
Agent calls gate_check:
{
"projectRoot": "/Users/you/projects/my-app",
"files": ["src/routes.ts"],
"threshold": 0.5
}Result:
{
"verdict": "BLOCK",
"scanSummary": "BLOCK, 8 affected across src/routes (4), src/pages (2), src (2)",
"recommendation": "Refactor the circular dependency before shipping this change.",
"riskScore": 0.35,
"reasons": [
"Changed files participate in a circular dependency. Example: src/router.ts → src/routes.ts"
],
"affectedFiles": 8,
"circularDependencies": 1,
"affectedCycles": [["src/router.ts", "src/routes.ts"]]
}Agent: "The gate check returned BLOCK — routes.ts is part of a cycle, so I should untangle that before making more changes."
Agent calls detect_cycles:
{
"projectRoot": "/Users/you/projects/my-app"
}Result:
{
"cycleCount": 2,
"hotspots": ["src/router.ts", "src/routes.ts"],
"cycles": [
["src/router.ts", "src/routes.ts"],
["src/cache/index.ts", "src/cache/store.ts"]
]
}┌─────────────┐ ┌──────────────┐ ┌──────────────┐
│ Agent asks │────▶│ ts-morph │────▶│ In-memory │
│ "safe to │ │ parses │ │ dependency │
│ change?" │ │ imports │ │ graph │
└─────────────┘ └──────────────┘ └──────┬───────┘
│
┌──────────────┐ ┌───────▼───────┐
│ PASS/WARN/ │◀────│ BFS traverse │
│ BLOCK │ │ reverse deps │
│ + risk 0-1 │ │ + risk score │
└──────────────┘ └───────────────┘Parse: ts-morph scans your project for ESM imports, re-exports, and CommonJS requires
Graph: Builds an in-memory dependency graph (no database, no persistence)
Analyze: BFS traversal of reverse dependencies from changed files
Score: Risk = affected files / total files (0-1)
Verdict: PASS (< 60% of threshold), WARN (60-100%), BLOCK (> threshold)
Supports: ESM imports, ESM re-exports, CommonJS require(), NodeNext-style .js → .ts resolution.
If you are choosing a tool for an agent or reviewer, the key question is still simple: do you need to explore a dependency graph, retrieve broader repo context, or package for a marketplace, or do you need to gate already-known changed files locally, at commit time, with a PASS/WARN/BLOCK verdict? CodeImpact MCP is built for that second job.
Alternative | Best at | Where it wins today | Where CodeImpact MCP wins |
CodeImpact MCP | Decision-first dependency gating for proposed TS/JS changes, including monorepos | Immediate PASS/WARN/BLOCK output at commit time on already-known changed files, built-in | Best fit when the job is "is this safe to commit?" rather than "help me explore the whole repo" |
code-graph-mcp | Hosted or prebuilt code-graph inspection through an MCP surface | Better when the agent wants graph traversal, semantic graph queries, and public/private graph access through the existing DeepGraph or CodeGPT flow instead of a local gate-first CLI | Better when you want one bounded pre-commit verdict with affected-file triage instead of a graph-exploration session |
Depwire | Broader dependency intelligence and architecture workflows across a wider language/tooling surface | Better when you need symbol-level analysis, browser visualization, security or health workflows, or a wider multi-language platform than CodeImpact intentionally targets | Better when you want a small MIT tool that stays local-first, is already live in the Official MCP Registry, and answers the narrow gating question quickly |
RepoGraph | Repository-level graph retrieval for SWE-style context gathering | Better when the workflow is researchy or retrieval-heavy, especially line-level repo context for larger repo-understanding loops rather than a lightweight commit-time check | Better when the touched files are already known and you only need bounded blast-radius triage plus a gate result |
CodeGraphContext | Broader local code graph and context platform with dual CLI + MCP entrypoints | Better when the agent needs queryable local graph/indexing workflows and longer-form repository reasoning across the local codebase, rather than one commit-time verdict for already-known changed files | Better when you want a fast local PASS/WARN/BLOCK gate with bounded blast-radius triage for known file changes, not a broader graph/context workflow |
MCP Hive style marketplace follow-up | Manual marketplace/discovery submission after the repo truth is already stable | Better when the job is marketplace packaging, screenshots, and operator copy for a directory workflow rather than technical gating itself | Better when you need the product wedge first: local verdicts, install-hook wiring, and bounded Python impact checks that are already shipped before any manual listing follow-up |
Choose CodeImpact MCP when: you already know the files in play and want a fast, local, MIT-licensed answer with a risk score, explicit cycle surfacing, file-level blast-radius output, monorepo-aware checks, the shipped Husky install-hook helper, and a clear PASS/WARN/BLOCK verdict before commit.
Choose one of the alternatives when: the main job is hosted/public graph access, graph exploration, repo understanding, wider dependency workflow coverage, graph-database-backed context retrieval for longer reasoning loops, or manual marketplace packaging after the core repo surface is already settled.
Q: Does it access the network? A: No. CodeImpact MCP is 100% local-first. It reads your project files via ts-morph and never makes network requests. No API keys, no cloud, no telemetry.
Q: Will it modify my code?
A: No. All 5 tools are read-only (annotated with readOnlyHint: true). They analyze but never write.
Q: How accurate is the risk score? A: The risk score is a graph-based heuristic (affected files / total files). It does not know about runtime behavior, tests, or data migrations. Treat it as a triage signal, not a guarantee.
Q: What languages does it support today?
A: Full support is still centered on TypeScript and JavaScript files (.ts, .tsx, .js, .jsx, .mts, .cts, .mjs, .cjs). There is also a bounded Python path for analyze_impact and gate_check when changed files are .py, but it stays at file/module-level impact instead of broad multi-language platform coverage or repo-wide graph exploration.
Q: How fast is it? A: Graph building typically takes 1-5 seconds depending on project size. Individual tool calls against a cached graph are near-instant.
Q: Does it cache the graph?
A: Yes, the graph is cached in-memory per (projectRoot, tsconfigPath) pair. Use refresh_graph to rebuild after significant changes.
Full graph depth is still strongest for TypeScript/JavaScript; Python support is intentionally bounded to local file/module-level impact, not a full multi-language platform.
No distinction between runtime imports and type-only imports
Graph is in-memory only (no persistence across server restarts)
Risk score is structural, not semantic — it doesn't know which files are "important"
No visualization output (text/JSON only)
See CHANGELOG.md for release history.
MIT — free to use in any project, commercial or personal.
Issues and PRs welcome at github.com/vk0dev/code-impact-mcp.
Analyze the blast radius of changing specific files. Returns which files would be directly and transitively affected, with a risk score (0-1). Use BEFORE committing multi-file changes to understand what might break. Does NOT modify any files.
| Name | Required | Description | Default |
|---|---|---|---|
| files | Yes | Relative file paths that are being changed (e.g. ['src/utils/helpers.ts']) | |
| projectRoot | Yes | Absolute path to the project root directory | |
| tsconfigPath | No | Optional tsconfig path relative to projectRoot |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description confirms the tool is read-only ('Does NOT modify any files'), consistent with the readOnlyHint annotation. It also details the output format (directly and transitively affected files, risk score 0-1), adding behavioral context beyond the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only two sentences, both dense: first sentence covers purpose and output, second provides usage guidance. No wasted words, and key information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 parameters and no output schema, the description explains the output format and usage context adequately. It lacks examples or error conditions, but covers the essential aspects well given the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add additional meaning to the parameters (files, projectRoot, tsconfigPath) beyond what the schema already provides, so no improvement over baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'analyze[s] the blast radius of changing specific files' and returns affected files and a risk score. This is a specific verb-resource pairing and distinguishes it from siblings like get_dependencies (which only lists direct dependencies).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly advises using the tool 'BEFORE committing multi-file changes to understand what might break,' providing clear context. However, it does not mention when not to use it or explicitly name alternatives, though siblings are listed in context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return strongly connected components with more than one file from the current dependency graph. Use it to inspect circular dependencies before refactors or release gates.
| Name | Required | Description | Default |
|---|---|---|---|
| projectRoot | Yes | Absolute path to the project root directory | |
| tsconfigPath | No | Optional tsconfig path relative to projectRoot |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description aligns with readOnlyHint annotation by stating it returns components from the current graph. It adds specific behavioral detail about what it returns (SCCs with >1 file), which goes beyond the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first states the action and result, second provides usage guidance. Information is front-loaded and every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 2 parameters, no output schema, and read-only annotation, the description adequately covers purpose, behavioral traits, and usage. It lacks details about the output format or behavior when no cycles exist, but this is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Both parameters are fully described in the input schema (100% coverage). The description does not add any additional semantic meaning beyond what the schema already provides, so baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns strongly connected components with more than one file from the dependency graph, and positions it for inspecting circular dependencies. This distinguishes it from sibling tools like get_dependencies and analyze_impact.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use it to inspect circular dependencies before refactors or release gates', providing clear usage context. However, it does not mention when not to use or explicitly name alternatives, though context with sibling tools implies distinctions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Pre-commit safety gate. Analyzes specified changes and returns a PASS/WARN/BLOCK verdict with reasons. Use as a bounded decision aid before committing multi-file changes. BLOCK means current impact is too risky. WARN means human review recommended. PASS means low-risk.
| Name | Required | Description | Default |
|---|---|---|---|
| files | Yes | Relative file paths being changed | |
| threshold | No | Risk threshold for BLOCK verdict (0-1, default 0.5) | |
| projectRoot | Yes | Absolute path to the project root directory | |
| tsconfigPath | No | Optional tsconfig path relative to projectRoot |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=true, and the description aligns by saying 'analyzes'. The description adds verdict meanings but no further behavioral details like performance or error cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences pack the purpose, usage, and verdict definitions with no waste. Front-loaded with key action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Explains verdict types but omits output format (e.g., JSON structure) and doesn't mention that it's read-only (covered by annotation). Adequate for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so description does not need to add parameter details. It does not provide extra context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes specified changes and returns a PASS/WARN/BLOCK verdict with reasons, distinguishing it from sibling tools like analyze_impact and detect_cycles.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says to use it as a bounded decision aid before committing multi-file changes, but does not mention when not to use it or compare to alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the import and importedBy relationships for a specific file. Shows what this file depends on and what depends on it. Use to understand coupling before refactoring a file.
| Name | Required | Description | Default |
|---|---|---|---|
| file | Yes | Relative file path (e.g. 'src/server.ts') | |
| projectRoot | Yes | Absolute path to the project root directory | |
| tsconfigPath | No | Optional tsconfig path relative to projectRoot |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds that the tool shows both directions of dependencies, providing useful behavioral context beyond the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with action and resource, with no redundant words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description could include more about the return format, but it is sufficient for a simple read-only query tool with well-documented parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add additional details about parameters beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'import and importedBy relationships for a specific file', distinguishing it from siblings like analyze_impact or detect_cycles.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a specific use case: 'Use to understand coupling before refactoring a file', but does not explicitly state when not to use it or compare to alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Rebuild the dependency graph from scratch. Call this after significant file additions/deletions, or if analyze_impact results seem stale. Returns graph statistics including file count, edge count, build time, and any circular dependencies detected.
| Name | Required | Description | Default |
|---|---|---|---|
| projectRoot | Yes | Absolute path to the project root directory | |
| tsconfigPath | No | Optional tsconfig path relative to projectRoot |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description says 'Rebuild from scratch', implying a mutation, but the annotations declare readOnlyHint=true, directly contradicting the description. This severely misleads the agent about side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose, then usage guidance, then return values. No extraneous words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers purpose, when to use, and return statistics, but the annotation contradiction creates a major gap in understanding the tool's side effects. For a mutation tool, this omission is significant.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers both parameters fully (100% coverage). The description adds no extra parameter meaning beyond what the schema already provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Rebuild' and resource 'dependency graph from scratch', and it is distinct from siblings like 'get_dependencies' which reads, and 'analyze_impact' which analyzes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly mentions when to use: after significant file changes or when analyze_impact results seem stale. It does not explicitly state when not to use, but the provided context is clear and helpful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.6.10analyze_impactdetect_cyclesgate_checkget_dependenciesrefresh_graphEach tool has a clearly distinct purpose: get_dependencies shows direct relationships, analyze_impact computes transitive blast radius, detect_cycles finds circular dependencies, gate_check provides a safety verdict, and refresh_graph rebuilds the graph. No overlap or ambiguity.
All tool names follow a consistent verb_noun pattern (get_dependencies, analyze_impact, detect_cycles, gate_check, refresh_graph), making them predictable and easy to distinguish.
With 5 tools, the server is well-scoped for its purpose of dependency impact analysis. Each tool covers a necessary aspect, and there are no superfluous or missing tools for the core workflow.
The tool set covers the full lifecycle: graph building (refresh_graph), dependency inspection (get_dependencies), impact prediction (analyze_impact), cycle detection (detect_cycles), and pre-commit validation (gate_check). No obvious gaps for the intended use case.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Deterministic context layer for your codebase: change impact, blast radius, answers with receipts.
Audit GitHub repos for malicious and supply-chain code before you depend on them.
API governance for AI agents. Detects breaking changes, scores blast radius, blocks unsafe calls.
Risk-scan a diff, flag AI-generated-code tells, find secrets. 5 of 7 tools need no account.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/vk0dev/code-impact-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
