Glob Pattern Tester MCP for AI. Validate File Paths Against Build Rules
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Glob Pattern Tester checks if any given file path matches complex glob patterns using the exact algorithm found in npm and git.
This is essential for validating everything from .gitignore rules to CI/CD pipeline includes. Don't guess whether a pattern like `src/**/*.ts` covers `src/utils/helper.ts`; let this MCP give you a definitive, reliable boolean match result.
What your AI can do
Test glob
Pass a glob pattern and file path to confirm if the path matches, using npm's exact matching algorithm.
Tests if a given string (the file path) is included in the set defined by a glob pattern.
Supports standard glob characters, including * for any character sequence, ? for a single character, and ** for directory recursion.
Allows testing patterns with negation (!) to determine if a file path explicitly fails to match a rule set.
Ask an AI about this
Waiting for input…
Glob Pattern Tester: 1 Tool
Use this tool to validate whether a given file path matches or fails to match any specified glob pattern, ensuring your rules are accurate.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Glob Pattern Tester on VinkiusTest Glob
Pass a glob pattern and file path to confirm if the path matches, using npm's exact matching algorithm.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Glob Pattern Tester integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Glob Pattern Tester, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by minimatch. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 1 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
The manual process for validating file rules is slow and error-prone.
Right now, if you want to know if your deployment pattern works, you have two options: either manually run a series of shell commands against a test directory or write complex regex patterns. This involves copy-pasting the rule into multiple testing environments and checking console output for every single path.
With this MCP, that whole process is gone. You simply pass your glob pattern and the file path to `test_glob`. The agent returns an immediate boolean result, confirming whether the build rule matches the file without running a single command line utility.
The Glob Pattern Tester gives you definitive answers.
You no longer need to juggle multiple tools or worry about which regex engine is handling your wildcard characters. You just input the rule and the path, and get a single answer that respects the standards used by npm and git.
It's simple: you tell your agent what needs to match, and it tells you if it works. That’s how reliable build pipelines are built.
What your AI can actually do with this
Writing build scripts or setting up deployment filters means dealing with path patterns constantly. You need to know if your file structure matches the rules defined in a configuration file—and guessing is a recipe for broken builds. This connector gives your agent the definitive answer. It uses the same matching engine trusted by industry tools like npm and git, so you never have to worry about pattern drift or inaccurate logic.
When you connect this MCP through Vinkius, your agent can treat path validation as a reliable function call, verifying whether a file actually adheres to complex patterns using full support for wildcards, negation, and grouping. This capability stops entire classes of build failures before they even start.
019e38a0-5a26-7061-b374-825cfe504440 
Here's how it actually works
The bottom line is that you get an immediate, deterministic yes or no answer on whether your path rules are correct.
You provide the agent with two specific strings: the pattern (e.g., src/**/*.js) and the target file path (e.g., src/components/Button.js).
The MCP executes its built-in matching logic, simulating how a major build tool processes the rule set against the file system.
Your agent receives a simple boolean result: true if the file matches the pattern, or false otherwise.
Who is this actually for?
The DevOps engineer who spends too much time debugging why a file was accidentally excluded from the build. The CI/CD specialist tired of flaky pipelines. Any developer whose job involves writing or maintaining complex include/exclude rules for large codebases.
Validates .gitignore entries and deployment filters to ensure that only intended files are built or pushed.
Checks CI pipeline include/exclude patterns against the current directory structure before initiating a build step.
Ensures that generated assets or included modules correctly adhere to defined path rules across different environments.
What Changes When You Connect
Stop guessing if a file matches a build rule. Use the test_glob tool to confirm path validity using the same logic npm and git use, eliminating guesswork.
Manage complex exclusions reliably. You can test negation patterns (like !dist/**) to ensure files are correctly skipped during deployment filtering.
Save time debugging flaky pipelines. By testing paths upfront with test_glob, your agent verifies rules before the build even starts failing.
Handle deep directory structures easily. The support for recursive globbing (**) ensures that patterns like src/**/*.ts cover all files, no matter how deep they are nested.
Build robust CI/CD logic. When integrating this MCP via Vinkius, your agent can verify file system rules and path validation data in any autonomous code workflow.
See it in action
Updating a .gitignore File
A developer is adding new build artifacts to .gitignore. Instead of committing the rule and waiting for a failure, they ask their agent: 'Does the pattern *.log exclude all files in the build/ directory?' The agent uses test_glob to return a definitive match result, confirming the exclusion works before they push code.
Verifying Asset Inclusion for Deployment
The ops engineer needs to ensure all compiled components are included in the deployment package. They ask: 'Will src/**/*.js match the path dist/utils/helper.js?' The agent uses test_glob to confirm the file exists within the scope of the build pattern, preventing missing assets.
Troubleshooting CI Build Failures
A pipeline fails because a specific asset is being ignored. The user runs: 'Check if !src/api/** excludes the file src/api/v2/users.ts?' Using test_glob, the agent confirms whether the exclusion rule was too broad or incorrectly structured.
Testing Manifest File Generation
A platform developer writes a manifest that relies on glob patterns to find all dependencies. They run: 'Does lib/** match lib/core/index.js?' The agent uses test_glob to validate the pattern immediately, ensuring the build script won't miss any files.
The honest tradeoffs
Writing manual regex for paths
Assuming that a complex file path check can be handled with simple regular expressions like .*\.[a-z]{2}$ when the pattern needs to account for directory structure.
Use this MCP. The test_glob tool is built specifically for glob patterns, which handle directory structures and wildcards much more reliably than general regex.
Relying on file system API calls
Calling a generic OS function to check path existence. This only checks if the path exists, not if it matches the intended rule set (e.g., checking for src/ when the rule was supposed to be src/**/*.ts).
Use test_glob. It combines both concepts: checking if a path exists AND confirming that it adheres strictly to the specified glob pattern.
Hardcoding patterns in scripts
Embedding a static rule like 'src/components/*.tsx' directly into multiple build scripts, making updates tedious and error-prone across different services.
Centralize your logic. Use the agent to execute test_glob checks against dynamic inputs, validating rules in one place before deploying them anywhere.
When It Fits, When It Doesn't
Use this MCP if your core problem is pattern matching—you need to validate whether a file path matches a rule defined by wildcards and directory structure. If you're dealing with .gitignore files, asset manifest rules, or build inclusion filters, this tool is non-negotiable.
Don't use it if your goal involves network calls (e.g., 'get the latest version from an API'), database queries ('find users where status=active'), or state management beyond simple path validation. For those cases, you need a different type of MCP connector.
Questions you might have
Does Glob Pattern Tester handle recursive directories? +
Yes, it supports full recursion using the ** wildcard. This lets you write patterns like src/**/*.ts, ensuring that every TypeScript file in every subdirectory is matched.
Can I use ! with Glob Pattern Tester for exclusions? +
Absolutely. You can test exclusion rules by including the negation operator (!). This helps confirm if a specific path will be explicitly skipped by your build system's logic.
Is the glob matching in Glob Pattern Tester the same as git? +
Yes. The MCP uses the minimatch engine, which is the exact engine behind npm and Git. This guarantees that the validation result you get matches what those tools use.
How do I test a simple file match with Glob Pattern Tester? +
You provide the pattern (e.g., *.json) and the path (package.json). The agent will run this through test_glob and return true if it matches, or false if it doesn't.
How does the `test_glob` function handle malformed patterns or file paths? +
It handles bad inputs gracefully by returning a specific error message. The MCP won't crash; it reports invalid input, allowing your agent to know exactly what went wrong with the pattern string.
Does `test_glob` require absolute paths or relative paths for accurate results? +
Relative paths are fine, provided they maintain consistent separators. Since the engine matches strings, as long as both inputs use the same path separator (like /), you'll get a reliable match result.
How efficient is `test_glob` when I check patterns against hundreds of files? +
It performs quickly because it relies on the highly optimized minimatch engine. The performance scales well, making it suitable for bulk validation tasks in CI/CD pipelines.
What kind of data types are accepted by `test_glob`? +
The tool accepts both the glob pattern and the file path as standard strings. It's designed for string-based text matching, useful for validating anything that follows a path structure.
Is this the same algorithm git uses? +
Yes. minimatch is the glob engine used by npm itself and follows the same POSIX glob specification that git uses for .gitignore.
Does it support double-star recursive patterns? +
Yes. The ** pattern matches any number of directories recursively. For example, src/**/*.ts matches files at any depth inside src/.
Can I test negation patterns? +
Yes. Prefix any pattern with ! to negate it. For example, !node_modules/** will NOT match any path inside node_modules.
We've already built the connector for Glob Pattern Tester. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 1 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.