MCP Workflow Engine
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@MCP Workflow Engine check the impact of modifying src/services/user.ts"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Workflow Engine
MCP server that provides AI coding agents with dependency analysis, impact detection, and build verification tools.
Tools Provided
Tool | Description |
| Find all files affected by changes to a file |
| Aggregate impact across a diff or git changeset |
| List what a file imports |
| Get dependency graph statistics and circular deps |
| Run build and return pass/fail with errors |
| Run TypeScript type checking |
| Run linter |
| Suggest test files impacted by a change |
| Run tests (auto-detected if not provided) |
| Run only a provided list of tests (uses |
| Highlight potential API/contract impacts |
| Generate verification checklist for a file type |
| Generate checklists for multiple files |
| Clear cached dependency graph |
Related MCP server: Merovingian MCP Server
Auto-Detection Behavior
Dependency scanning defaults to
src, but if it doesn't exist the server auto-detects common source roots (e.g.lib,app,apps,packages,services) and includes common test dirs (test,tests,__tests__,spec,specs) when present.You can override scanning with
scan_dirs,project_root, andignore_patterns.Build and test commands auto-detect common ecosystems (Node, Gradle, Maven, .NET, Go, Rust, Python, Make). You can always pass an explicit
command.
Installation
cd mcp-workflow
npm install
npm run buildConfiguration
Claude Code
Add to ~/.claude/settings.json:
{
"mcpServers": {
"workflow-engine": {
"command": "node",
"args": ["C:/path/to/mcp-workflow/dist/server.js"]
}
}
}Codex CLI
Add to ~/.codex/config.toml:
[mcp_servers.workflow-engine]
command = "node"
args = ["C:/path/to/mcp-workflow/dist/server.js"]Repo Config (.workflow-engine.json)
Place this in the repo being analyzed (the project_root). It overrides auto-detection.
Notes:
ignorePatternsare regular expressions matched against normalized paths (e.g.src/foo/bar.ts).testCommandsupports{tests}placeholder for targeted runs.dependencyCruiserOptionsis passed through to dependency-cruiser (advanced use).contractDirsscopes where contract files are discovered (defaults to common docs/spec folders).
{
"scanDirs": ["src", "packages"],
"testDirs": ["tests", "__tests__"],
"ignorePatterns": ["\\.generated\\.", "^dist/"],
"contractDirs": ["docs", "spec", "openapi"],
"buildCommand": "pnpm build",
"testCommand": "pnpm test -- {tests}",
"dependencyCruiserOptions": {
"tsConfig": "tsconfig.json"
}
}Usage Examples
Once configured, the agent can call these tools:
Before implementing a change
Agent: I need to modify src/services/user.ts. Let me check the impact.
[Calls get_impact(file="src/services/user.ts", project_root="C:/path/to/project")]
Result:
{
"file": "src/services/user.ts",
"directDependents": ["src/controllers/auth.ts", "src/controllers/admin.ts"],
"transitiveDependents": ["src/routes/api.ts"],
"associatedTests": ["src/services/__tests__/user.test.ts"],
"totalImpacted": 3
}Get verification checklist
Agent: What should I verify for this change?
[Calls chain_effect_checklist(file="src/services/user.ts")]
Result:
{
"file": "src/services/user.ts",
"fileType": "Service/Domain",
"checklist": [
{"category": "Controllers", "check": "Verify all calling controllers handle new behavior"},
{"category": "Return Types", "check": "Check if return type changes affect callers"},
...
]
}After implementing
Agent: Let me verify the build passes.
[Calls verify_build()]
Result:
{
"success": true,
"output": "Build completed successfully",
"errors": [],
"duration": 3420
}Diff-aware impact
Agent: What will this diff impact?
[Calls get_impact_from_diff(cwd="C:/path/to/project")]Relevant tests + execution
Agent: Which tests should I run?
[Calls get_relevant_tests(files=["src/services/user.ts"], project_root="C:/path/to/project")]
Agent: Run those tests.
[Calls run_relevant_tests(tests=["src/services/__tests__/user.test.ts"], command="pnpm test -- {tests}")]Contract impact
Agent: Any contract updates needed?
[Calls get_contract_impact(files=["src/controllers/user.ts"], project_root="C:/path/to/project")]Workflow Integration
Pair with an AGENTS.md file in your repo:
## Required Workflow
### Step 1: Impact Analysis
Before implementing, use `get_impact` to identify all affected files.
### Step 2: Chain-Effect Checklist
Use `chain_effect_checklist` to get verification items for the file type.
### Step 3: Implementation
Make changes across all affected layers.
### Step 4: Build Verification
Use `verify_build` - task is NOT complete unless this returns success.Development
npm run dev # Watch mode
npm run build # Build once
npm start # Run serverLicense
MIT
Available Tools
14 toolschain_effect_checklistA
Generates a checklist of things to verify based on the type of file being changed. Use this to ensure you don't miss any ripple effects of your changes.
Inputs: file (required).
get_contract_impactC
Highlights potential contract/API impacts and suggests checks.
Inputs: cwd, diff, files, base_ref, +3 more.
get_dependenciesB
Returns the list of files that a specific file imports/depends on. Useful for understanding what a file relies on.
Inputs: file (required), src_dir, scan_dirs, project_root, +1 more.
get_graph_statsB
Returns statistics about the dependency graph including total modules, total dependencies, and any circular dependencies detected.
Inputs: src_dir, scan_dirs, project_root, ignore_patterns.
get_impactA
Analyzes the dependency graph to find all files impacted by changes to a specific file. Returns direct dependents, transitive dependents, and associated test files. Use this BEFORE implementing changes to understand the full scope of impact.
Inputs: file (required), src_dir, scan_dirs, project_root, +1 more.
get_impact_from_diffB
Aggregates impact analysis across a diff or Git changeset. Provide a diff string, or let it use git to discover changed files.
Inputs: cwd, diff, src_dir, base_ref, +5 more.
get_relevant_testsC
Returns a list of tests likely impacted by the given files or diff.
Inputs: cwd, diff, files, command, +7 more.
invalidate_graph_cacheA
Invalidates the cached dependency graph. Use this after making changes to files so that subsequent impact analysis reflects the new state.
Inputs: no named parameters.
multi_file_checklistA
Generates checklists for multiple files being changed. Use this when your change spans multiple files.
Inputs: files (required).
run_lintC
Runs the linter and returns any linting errors.
Inputs: cwd, command.
run_relevant_testsC
Runs tests for a provided list. Use {tests} in the command for precise selection.
Inputs: tests (required), cwd, command, timeout, +1 more.
run_testsC
Runs the project's test command (auto-detected if not provided).
Inputs: cwd, command, timeout.
run_typecheckA
Runs TypeScript type checking (tsc --noEmit) and returns any type errors. Use this to catch type errors without running the full build.
Inputs: cwd.
verify_buildA
Runs the build command and returns success/failure with any errors. Use this AFTER implementing changes to verify the build passes. A task is NOT complete until this returns success.
Inputs: cwd, command, timeout.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Most tools have clearly distinct purposes: impact analysis, test selection, build verification, and checklist generation are separated by action and input scope. The only mild ambiguity is between chain_effect_checklist and multi_file_checklist, and between get_impact and get_contract_impact, but their descriptions clarify the intended use.
The naming pattern is largely consistent, using verb_noun pairs like run_lint, get_dependencies, verify_build, and invalidate_graph_cache. The exceptions are chain_effect_checklist and multi_file_checklist, which drop the leading verb and break the otherwise predictable pattern.
At 14 tools, the surface is well-scoped for a workflow engine covering linting, type checking, builds, tests, impact analysis, and checklists. Each tool addresses a meaningful stage in the change workflow without unnecessary redundancy.
The tool set covers the full change lifecycle: pre-implementation impact analysis, implementation-time verification, test identification and execution, and post-change cache invalidation. It also includes checklist generation to guard against missed ripple effects, with no critical dead ends or missing core operations.
Maintenance
Related MCP Connectors
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Codebase intelligence for AI agents — dead code, blast radius, ownership.
AI Agent with Architectural Memory. Impact analysis (free), tests and code from the graph (pro).
Change-aware CI validation and affected-test guidance for coding agents.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceProvides code intelligence for AI coding agents by indexing repositories into a hybrid knowledge graph, enabling agents to query dependencies, impact, and context through 28 MCP tools.4Apache 2.0
- AlicenseAqualityDmaintenanceEnables AI agents to map cross-repository dependencies, detect breaking changes in API contracts, and assess impact across services.10MIT
- AlicenseNot gradedqualityBmaintenanceProvides a dependency graph of any local repository with tools for change impact, transitive dependents, health audits, and more, enabling AI coding agents to see structure and refactor safely.4,912 npm4MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to query and analyze code across multiple repositories through a unified knowledge graph, with tools for symbol search, impact analysis, and graph algorithms.54 npmMIT