MCP Probe Kit

🚀 MCP Probe Kit

A powerful development enhancement toolset for Cursor - enabling AI to better understand your development workflow

The MCP Probe Kit is a robust MCP (Model Context Protocol) server that offers 23 practical tools, covering the entire process of code quality, development efficiency, and project management.

Author: Kyle | Project: GitHub

✨ Features

🔍 Code Quality (7 tools)

• detect_shell - AI model shell detection
• code_review - Code review assistant
• debug - Intelligent debugging assistant
• gentest - Test case generator
• refactor - Refactoring suggestions
• perf - Performance analysis
• fix - Automatically fix code issues 🆕

🛠️ Development Efficiency (11 tools)

• gencommit - Generate Git commit messages
• genapi - Generate API documentation
• gendoc - Generate code comments
• genpr - Generate PR descriptions
• genchangelog - Generate Changelogs
• gensql - SQL query generator 🆕
• genui - UI component generator (React + Vue) 🆕
• explain - Code interpreter 🆕
• convert - Code converter 🆕
• genreadme - README generator 🆕
• split - File splitting tool 🆕

📦 Project Management (5 tools)

• init_setting - Initialize Cursor AI configuration
• init_project - Initialize Spec-Driven projects
• check_deps - Check dependency health
• resolve_conflict - Git conflict resolution assistant 🆕
• analyze_project - Project analysis tool to help AI quickly understand legacy projects 🆕

🚀 Quick Start

📦 Method 1: Use directly with npx (Recommended)

Use directly without installation:

# Configure the MCP server in Cursor

Configuration path for Windows:

%APPDATA%\Cursor\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json

Configuration path for macOS/Linux:

~/Library/Application Support/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Configuration content:

{
  "mcpServers": {
    "mcp-probe-kit": {
      "command": "npx",
      "args": ["mcp-probe-kit@latest"],
      "env": {}
    }
  }
}

📦 Method 2: Global installation

# Install globally
npm install -g mcp-probe-kit

# Configure in Cursor

Configuration content:

{
  "mcpServers": {
    "mcp-probe-kit": {
      "command": "mcp-probe-kit"
    }
  }
}

📦 Method 3: Local project installation

# Install in the project
npm install mcp-probe-kit

# Configure in Cursor (using the project path)

Configuration content:

{
  "mcpServers": {
    "mcp-probe-kit": {
      "command": "node",
      "args": ["./node_modules/mcp-probe-kit/build/index.js"]
    }
  }
}

🔧 Development mode (Local development)

If you are developing or modifying tools locally:

For Windows:

%APPDATA%\Cursor\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json

For macOS/Linux:

~/Library/Application Support/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Configuration content:

{
  "mcpServers": {
    "mcp-probe-kit": {
      "command": "node",
      "args": ["D:/workspace/github/mcp-probe-kit/build/index.js"]
    }
  }
}

⚠️ Important: Modify the path to your actual project path

🔄 Restart Cursor

After configuration, completely exit Cursor and then reopen it (not just reload the window)

📖 Tool Usage Guide

🔍 Code Quality Tools

detect_shell - Shell Detection

Detect whether an AI model is being proxied/wrapped and generate a JSON fingerprint for verification.

Usage: detect_shell

code_review - Code Review

Comprehensively review code quality, security, performance, and best practices.

Usage: code_review or code_review @file.ts

Review content: Code smells, security vulnerabilities, performance issues, naming conventions

debug - Debugging Assistant

Analyze errors and generate debugging strategies and solutions.

Usage: debug and then paste the error message

Output: Error classification, problem location, debugging steps, solutions, verification checklist

gentest - Test Generation

Generate complete test cases for the code (supports Jest/Vitest/Mocha).

Usage: gentest @function.ts

Generated content: Unit tests, boundary tests, exception tests, Mock data

refactor - Refactoring Suggestions

Analyze the code and provide refactoring suggestions and implementation plans.

Usage: refactor @messy-code.ts

Suggested content: Identify code smells, refactoring steps, risk assessment, expected benefits

perf - Performance Analysis

Analyze code performance bottlenecks and provide optimization suggestions.

Usage: perf @slow-function.ts

Analysis dimensions: Algorithm complexity, memory usage, React performance, database queries

fix - Automatic Fix 🆕

Automatically fix code issues (Lint errors, TypeScript type errors, formatting issues).

Usage: fix @file.ts or fix (fix all files)

Fix types: lint, type, format, import, unused, all (default)

Functions:

• Automatically fix Lint errors
• Fix TypeScript type errors
• Code formatting
• Optimize Import statements
• Remove unused code

🛠️ Development Efficiency Tools

gencommit - Commit Generation

Automatically analyze code changes and generate standardized Git commit messages (supports emojis).

Usage: gencommit

Format: <type>: <emoji> <subject> (Following Conventional Commits)

Types:

• fixed 🐛 - Fix online/test defects
• fix 🐛 - Semantically the same as fixed, for compatibility
• feat 🎸 - Add or iterate on business features
• docs ✏️ - Update documentation
• style 💄 - Adjust UI/styles
• chore 🤖 - Miscellaneous tasks like building, scripts, dependencies
• refactor ♻️ - Refactoring
• test ✅ - Related to testing

Example:

feat: 🎸 Add user login functionality

Affected module: auth
- Implement JWT authentication mechanism
- Add password encryption storage

genapi - Documentation Generation

Generate API documentation for the code (supports Markdown/OpenAPI/JSDoc).

Usage: genapi @api/user.ts

Formats: markdown (default), openapi, jsdoc

gendoc - Comment Generation

Generate detailed JSDoc/TSDoc comments for the code.

Usage: gendoc @function.ts

Included: Function description, parameter explanation, return value, exception cases, usage examples

genpr - PR Generation

Analyze changes and generate standardized Pull Request descriptions.

Usage: genpr

Included: Change summary, technical details, test instructions, notes, checklist

genchangelog - Changelog Generation

Generate CHANGELOG.md based on the commit history.

Usage: genchangelog v1.2.0

Format: Keep a Changelog standard

gensql - SQL Generator 🆕

Generate SQL query statements based on natural language descriptions.

Usage: gensql and then describe the requirements (e.g., "Query users whose purchase amount exceeds the average")

Supported: PostgreSQL, MySQL, SQLite

Functions:

• Generate complex queries (JOIN, subqueries, window functions)
• Generate table creation statements
• Provide index optimization suggestions
• Analyze query performance

genui - UI Component Generator (React + Vue) 🆕

Generate React or Vue 3 UI component code.

Usage: genui and then describe the component (e.g., "Create a Button component with a loading state")

Supported frameworks:

• React: Hooks, forwardRef, TypeScript
• Vue 3: Composition API, script setup, TypeScript
• HTML: Native JavaScript

Functions:

• Complete component implementation (TypeScript)
• Tailwind CSS / UnoCSS styles
• Accessibility (A11y) support
• Props/Emits type definitions
• Usage examples and best practices
• Component library recommendations (shadcn/ui, Element Plus, etc.)

explain - Code Interpreter 🆕

Explain the code logic and principles in detail to help understand complex code.

Usage: explain @complex-code.ts

Explained content:

• Overall function overview
• Line-by-line code explanation
• Core principle analysis
• Design pattern recognition
• Time/space complexity
• Usage scenarios and notes

Applicable scenarios:

• Understand legacy code
• Learn new frameworks/libraries
• Analyze complex algorithms
• Code Review

convert - Code Converter 🆕

Convert code formats or frameworks.

Usage: convert @file.js and then specify the conversion type (e.g., "Convert to TypeScript")

Supported conversions:

• JavaScript → TypeScript
• Class Component → Hooks
• Promises → Async/Await
• CommonJS → ESM
• CSS → Tailwind CSS
• Vue 2 → Vue 3
• JSON → TypeScript Interface

genreadme - README Generator 🆕

Automatically generate README.md documentation based on the project code.

Usage: genreadme or provide project information

Styles: standard, minimal, detailed

Included content:

• Project introduction and badges
• Installation and quick start
• Feature list
• Usage examples
• API documentation
• Configuration instructions
• Contribution guidelines

split - File Splitting Tool 🆕

Split large files into multiple small files or components to improve maintainability.

Usage: split @LargeFile.tsx or provide file content

Splitting strategies:

• auto (Automatic) - AI analyzes the best splitting method
• type (By type) - Separate type definitions, constants, utility functions
• function (By function) - Split multiple independent functions
• component (By component) - Split React/Vue components into subcomponents
• feature (By module) - Split functional modules (e.g., Redux store)

Applicable scenarios:

• Files with more than 300 lines
• Components with excessive responsibilities
• A hodgepodge of utility functions
• Hard-to-maintain code

Provided solutions:

• Analysis of splitting strategies
• Suggested directory structure
• Content of each new file
• Import/export relationships
• Migration steps

📦 Project Management Tools

init_setting - Configuration Initialization

Create a Cursor AI configuration file in the current project.

Usage: init_setting

Configuration: Claude Sonnet 4.5, temperature = 0, semantic retrieval

init_project - Project Initialization

Initialize the project in a Spec-Driven Development manner.

Usage: init_project, the requirement is: Create a task management system or init_project @requirements.md

Generated: constitution.md, spec.md, plan.md, tasks.md, research.md

Reference: GitHub Spec-Kit

check_deps - Dependency Check

Analyze the health of project dependencies (version, security, size).

Usage: check_deps

Checked: Outdated dependencies, security vulnerabilities, package size, unused dependencies

resolve_conflict - Git Conflict Resolution 🆕

Analyze and help resolve Git merge conflicts.

Usage: resolve_conflict and then paste the conflict content, or directly open the conflict file

Functions:

• Analyze the cause of the conflict
• Identify the intentions of both parties' modifications
• Recommend a merge solution
• Provide the complete resolved code
• Suggestions for conflict prevention

Applicable scenarios:

• Feature branch merging
• Rebase conflicts
• Cherry-pick conflicts

analyze_project - Project Analysis Tool 🆕

Deeply analyze the project structure, code quality, and architecture to help AI quickly understand legacy projects.

Usage: analyze_project or analyze_project @project-path

Parameters:

• project_path - Project path (default is the current directory)
• max_depth - Maximum depth of the directory tree (default is 5)
• include_content - Whether to include file content (default is true)

Analyzed content:

• Project overview: Project type, technology stack, framework, language, package manager
• Directory structure: Clear display of the directory tree
• Key files: Automatically identify important configuration files and provide usage instructions
• Dependency analysis: Statistics and health assessment of production and development dependencies
• Code metrics: Number of files, line count statistics, file type distribution, identification of the largest file
• Architectural patterns: Detection of design patterns, identification of entry files, analysis of core modules
• Intelligent suggestions: Assessment of project complexity and improvement suggestions

Applicable scenarios:

• 🔍 Quickly understand the project structure when taking over a legacy project
• 📊 Get an overview of the project before code review
• 🏗️ Plan architecture analysis and refactoring
• 📚 Generate project documentation
• 🤖 Help AI assistants better understand the project context

🎯 Usage Scenario Examples

📝 Daily development process

1. code_review @feature.ts     # Review the code before submission
2. gentest @feature.ts          # Generate test cases
3. genapi @api/user.ts          # Generate API documentation
4. gencommit                    # Commit the code

🐛 Debugging process

1. debug                        # Analyze the error
2. refactor @buggy-code.ts      # Get refactoring suggestions
3. gentest @fixed-code.ts       # Add tests
4. gencommit                    # Commit the fix

🚀 Starting a new project

1. init_project @requirements.md  # Initialize the project structure
2. init_setting                   # Configure AI
3. check_deps                     # Check dependency health
4. Start development...

🔍 Taking over a legacy project

1. analyze_project                # Deeply analyze the project structure
2. check_deps                     # Check dependency health
3. code_review                    # Review code quality
4. Start maintenance and development...

📦 Version release

1. code_review                  # Comprehensive code review
2. genchangelog v1.2.0          # Generate Changelog
3. genpr                        # Generate PR description
4. Release the version

🔍 Performance optimization

1. perf @slow-function.ts       # Analyze performance
2. refactor @slow-function.ts   # Refactor for optimization
3. gentest @optimized.ts        # Test and verify
4. gencommit                    # Commit the optimization

🛠️ Development Guide

Project Structure

mcp-probe-kit/
├── src/
│   ├── index.ts              # Main entry of the MCP server
│   └── tools/                # Tool implementations (23 in total)
│       ├── index.ts             # Export tools
│       ├── detect_shell.ts      # Shell detection
│       ├── code_review.ts       # Code review
│       ├── debug.ts             # Debugging assistant
│       ├── gentest.ts           # Test generation
│       ├── refactor.ts          # Refactoring suggestions
│       ├── perf.ts              # Performance analysis
│       ├── fix.ts               # Automatic fix
│       ├── gencommit.ts         # Commit generation
│       ├── genapi.ts            # Documentation generation
│       ├── gendoc.ts            # Comment generation
│       ├── genpr.ts             # PR generation
│       ├── genchangelog.ts      # Changelog generation
│       ├── gensql.ts            # SQL generator
│       ├── genui.ts             # UI component generator
│       ├── explain.ts           # Code interpreter
│       ├── convert.ts           # Code converter
│       ├── genreadme.ts         # README generator
│       ├── split.ts             # File splitting tool
│       ├── init_setting.ts      # Configuration initialization
│       ├── init_project.ts      # Project initialization
│       ├── check_deps.ts        # Dependency check
│       ├── resolve_conflict.ts  # Git conflict resolution
│       └── analyze_project.ts   # Project analysis
├── build/                    # Compiled output
├── package.json
├── tsconfig.json
└── README.md

Adding a new tool

1. Create a tool file: src/tools/your_tool.ts

export async function yourTool(args: any) {
  try {
    const message = `Your command content...`;
    return {
      content: [{ type: "text", text: message }],
    };
  } catch (error) {
    return {
      content: [{ type: "text", text: `❌ Error: ${error}` }],
      isError: true,
    };
  }
}

2. Export the tool: Add it in src/tools/index.ts

export { yourTool } from "./your_tool.js";

3. Register the tool: Add the tool definition and handling in src/index.ts

4. Rebuild:

npm run build

Development commands

# Install dependencies
npm install

# Compile
npm run build

# Watch mode (for development)
npm run watch

# Test the server
npm run dev

🔧 Configuration Instructions

MCP server configuration

Configuration file location (depending on your MCP client):

• Cursor: cline_mcp_settings.json
• Claude Desktop: claude_desktop_config.json

Tool parameter instructions

All tool parameters are optional, and the AI will automatically infer them. Common parameters:

❓ Frequently Asked Questions

Q1: What should I do if a tool fails to work or reports an error?

If you encounter installation or runtime issues, you can output detailed logs for troubleshooting in the following ways:

Windows (PowerShell):

npx -y mcp-probe-kit@latest 2>&1 | Tee-Object -FilePath .\mcp-probe-kit.log

macOS/Linux:

npx -y mcp-probe-kit@latest 2>&1 | tee ./mcp-probe-kit.log

This will save the error information to the mcp-probe-kit.log file, making it easier to troubleshoot problems or submit an Issue.

Q2: Why can't Cursor recognize the tools after configuration?

1. Completely exit Cursor and reopen it (not just reload the window).
2. Check if the configuration file path is correct:
   • Windows: %APPDATA%\Cursor\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
   • macOS/Linux: ~/Library/Application Support/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
3. Confirm that the JSON format is correct and there are no syntax errors.
4. Check the console logs in Cursor's developer tools (Help → Toggle Developer Tools).

Q3: Why is the npx method slow every time?

It is recommended to install globally to improve speed:

npm install -g mcp-probe-kit

Then modify the configuration to:

{
  "mcpServers": {
    "mcp-probe-kit": {
      "command": "mcp-probe-kit"
    }
  }
}

Q4: What if the content generated by the tool does not meet expectations?

All tools are instruction generators, and they generate clear instructions for the AI:

• The AI will understand your requirements based on the instructions.
• You can further clarify specific requirements in the conversation.
• For example, "Implement with React Hooks", "Add TypeScript types", etc.

Q5: How do I update to the latest version?

npx method (Recommended): Use the @latest tag in the configuration, and it will automatically use the latest version:

"args": ["mcp-probe-kit@latest"]

Global installation method:

npm update -g mcp-probe-kit

Check the current version:

npm list -g mcp-probe-kit

🤝 Contribution Guidelines

Welcome to submit Issues and Pull Requests!

Improvement suggestions:

• Add new practical tools
• Optimize the prompts of existing tools
• Improve documentation and examples
• Fix bugs

Development specifications:

• Follow the TypeScript specification.
• Keep tool names concise (preferably within 10 characters).
• Provide clear usage instructions and examples.
• Maintain the "instruction generator" mode (do not directly operate the file system).

📄 License

MIT License

🔗 Related Links

• Model Context Protocol (MCP)
• GitHub Spec-Kit
• Conventional Commits
• OpenAPI Specification

💡 Design Philosophy

Instruction Generator Mode

All tools adopt the instruction generator mode:

• The tools do not directly operate the file system or execute commands.
• Instead, they generate clear instructions to tell the AI what to do.
• After the AI understands the instructions, it uses Cursor's capabilities to complete the actual operations.

Advantages:

• ✅ Concise code, easy to maintain
• ✅ The AI can intelligently handle boundary cases
• ✅ Users can see the operation process, which is more transparent
• ✅ High flexibility, and the AI can adjust according to the actual situation

Why is it called Probe Kit?

• Probe: Detect code quality, performance bottlenecks, and dependency health.
• Kit: A set of 23 tools covering the entire development process.

Tool Classification

Code Quality (7)
├── detect_shell  Shell detection
├── code_review   Code review
├── debug         Debugging assistant
├── gentest       Test generation
├── refactor      Refactoring suggestions
├── perf          Performance analysis
└── fix           Automatic fix

Development Efficiency (11)
├── gencommit     Commit generation
├── genapi        Documentation generation
├── gendoc        Comment generation
├── genpr         PR generation
├── genchangelog  Changelog generation
├── gensql        SQL generator
├── genui         UI component generator
├── explain       Code interpreter
├── convert       Code converter
├── genreadme     README generator
└── split         File splitting tool

Project Management (5)
├── init_setting     Configuration initialization
├── init_project     Project initialization
├── check_deps       Dependency check
├── resolve_conflict Git conflict resolution
└── analyze_project  Project analysis tool

👨‍💻 Author

Kyle

• 🌐 Website: bytezonex.com
• 💼 Specializes in AI-assisted development tools

Made with ❤️ for Cursor Users