⚡ thevult.in DevKit

A developer productivity MCP server. Built by thevult.in.

Infrastructure for the ambitious.

Install

npx @thevultin/devkit

Or globally:

npm install -g @thevultin/devkit

Configure in Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "thevult-devkit": {
      "command": "npx",
      "args": ["-y", "@thevultin/devkit"]
    }
  }
}

Config file location:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
• Linux: ~/.config/Claude/claude_desktop_config.json

Tools

Core Development Tools

| Tool | Description | Status | |------|-------------|--------| | ping | Connectivity check. Verify server is running. | ✓ Core | | run_code | Execute code snippets in Python, JavaScript, Go with 10s timeout | ✓ Core | | analyze_code | Code quality analysis: LOC, cyclomatic complexity, smells, nesting depth | ✓ Core | | get_gitignore | Generate .gitignore for any language/framework stack | ✓ Core |

AI-Powered Intelligence Tools

| Tool | Description | Status | |------|-------------|--------| | review_diff | Analyze git diffs for N+1 queries, error handling, security issues, code smells | ✓ NEW | | explain_error | Root cause analysis for error stacktraces. Supports Python, JS, Go, Java, Rust, Ruby | ✓ NEW | | detect_secrets | Scan code/diffs for accidentally committed secrets (AWS keys, tokens, passwords) with ML confidence scoring | ✓ NEW | | detect_complexity_class | Measure empirical Big-O complexity by running code with increasing input sizes | ✓ NEW | | profile_memory | Multi-language memory leak detection: JavaScript, TypeScript, Python, Go, Rust, C, C++ | ✓ NEW |

Package & Project Tools

| Tool | Description | Status | |------|-------------|--------| | search_package | Look up packages on npm, PyPI, crates.io with metadata | ✓ Core | | scaffold_project | Generate project templates for Go microservices, Node.js, Python, Rust, React | ✓ Core |

Advanced Features

Memory Profiling (Multi-Language)

The profile_memory tool is enterprise-grade and supports:

• JavaScript/TypeScript: Node.js heap profiling with process.memoryUsage()
• Python: tracemalloc integration for precise memory tracking
• Go: runtime.MemStats for goroutine and allocation tracking
• Rust: sysinfo crate integration for process memory monitoring
• C/C++: /proc/self/status parsing on Linux + portable system calls

Detects memory leaks by fitting growth curve to O(1) vs O(n) trend, returns:

• Heap samples across iterations
• Growth rate per iteration
• Leak confidence score (0–1)
• Language-specific debugging recommendations

Usage Examples

1. Code Execution

"Run this Python snippet and tell me the output"

import math
print(math.factorial(10))

2. Code Analysis & Smells

"Analyze this function for quality issues"

function processUsers(ids: string[]) {
  for (const id of ids) {
    // N+1 query pattern
    const user = db.query(`SELECT * FROM users WHERE id = ${id}`);
    console.log(user.name);
  }
}

3. Git Diff Review (Security & Performance)

"Review this diff for issues before I merge"

+++ src/auth/token.ts
@@ -45,7 +45,7 @@
-  const secret = process.env.JWT_SECRET;
+  const secret = "sk_live_a1b2c3d4e5f6g7h8i9j0";

Returns: ⚠ CRITICAL: Hardcoded secret detected

4. Memory Leak Detection

"Profile this Python code for memory leaks"

# Memory is tracked across 100 iterations
cache = []
for i in range(n):
    cache.append(expensive_object())  # Leak!

5. Error Analysis

"Explain this stack trace"

TypeError: Cannot read property 'map' of undefined
    at processData (routes/api.js:42:15)

Returns root cause, fix suggestion, and code patch.

6. Complexity Analysis

"What's the Big-O complexity of this sort?"

def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(len(arr) - 1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

Returns: Empirical class: O(n²) with measurement graph.

7. Secret Detection

"Scan this diff for accidentally committed secrets"

Automatically detects and suppresses false positives, flagging only high-confidence findings.

Development

git clone https://github.com/blackvult/devkit
cd devkit
npm install
npm run dev       # watch mode
npm run build     # compile
npm start         # run the server

About

Built by Vishesh Rawal · thevult.in

Blackvult DevKit is an AI-powered development toolkit that goes beyond static analysis. Unlike traditional dev tools, each tool combines:

✓ Compute — Actual code execution, memory measurement, complexity fitting
✓ Intelligence — Model-driven analysis, false-positive filtering, pattern detection
✓ Multi-language support — Enterprise-grade tooling for 7+ languages

Why DevKit?

• Security: Detect hardcoded secrets with ML confidence scoring (not regex)
• Performance: Measure actual complexity vs theoretical Big-O
• Memory: Enterprise memory profiling across JavaScript, Python, Go, Rust, C/C++
• Velocity: Pre-commit code review that catches N+1 queries, silent errors, type issues
• Intelligence: Error explanation with root cause + fix recommendations

"Infrastructure for the ambitious."

API Reference

review_diff

Analyze git diffs for potential issues.

Input:

{
  "diff": "git diff output or unified diff format",
  "context": "optional: 'performance-critical path' or similar"
}

Output:

{
  "summary": "3 issues found",
  "issues": [
    {
      "severity": "high|critical|medium|low",
      "message": "SQL query in loop — N+1 problem",
      "line": 42,
      "file": "src/orders.ts"
    }
  ],
  "approved": false
}

explain_error

Analyze error stacktraces and provide root cause + fix.

Input:

{
  "stacktrace": "error stack trace from Python/JS/Go/Java/Rust/Ruby/PHP",
  "language": "python|javascript|go|java|rust|ruby|php",
  "context": "optional: running in Docker, under load, etc",
  "code_snippet": "optional: source code around error"
}

Output:

{
  "error_type": "KeyError",
  "root_cause": "Accessing a dictionary key that doesn't exist",
  "explanation": "The code tried to access...",
  "fix": "Use dict.get(key, default_value) instead of dict[key]",
  "severity": "high",
  "code_patch": "# Before: ...\n# After: ...",
  "next_steps": ["Review the error message", "Check source code", ...]
}

detect_secrets

Scan code or diffs for accidentally committed secrets.

Input:

{
  "diff": "optional: git diff output",
  "code": "optional: raw source code"
}

Output:

{
  "findings": [
    {
      "type": "AWS Access Key",
      "file": "config.yaml",
      "line": 14,
      "value_preview": "AKIA2Q5W...xx7f",
      "confidence": 0.99
    }
  ],
  "summary": "1 potential secret(s) found",
  "suppressed_false_positives": 3,
  "recommendation": "BLOCK THIS COMMIT. Rotate all exposed credentials immediately."
}

detect_complexity_class

Measure empirical Big-O complexity by running code with increasing input sizes.

Input:

{
  "code": "function test(arr) { return arr.filter(...).map(...); }",
  "language": "javascript|python",
  "input_generator": "def generate(n): return list(range(n))",
  "test_sizes": [10, 50, 100, 500, 1000]
}

Output:

{
  "empirical_class": "O(n log n)",
  "confidence": 0.94,
  "timings": [
    { "n": 10, "ms": 0.2 },
    { "n": 1000, "ms": 18.4 }
  ],
  "r_squared": 0.98,
  "recommendation": "Good logarithmic complexity — very efficient.",
  "fits": [
    { "complexity": "O(n log n)", "r_squared": 0.98 },
    { "complexity": "O(n²)", "r_squared": 0.62 }
  ]
}

profile_memory

Detect memory leaks by profiling across multiple programming languages.

Input:

{
  "code": "for i in range(n): cache.append(expensive_object())",
  "language": "javascript|typescript|python|go|rust|c|cpp",
  "iterations": 100,
  "interval_ms": 20,
  "setup_code": "optional: initialization code"
}

Output:

{
  "language": "python",
  "leaked": true,
  "growth_rate_per_iter": "~4KB per iteration",
  "suspected_object": "Unclosed file handles or circular references",
  "total_growth_mb": 0.45,
  "peak_memory_mb": 12.3,
  "confidence": 0.89,
  "heap_samples": [
    { "iteration": 0, "heap_used_mb": 10.2 },
    { "iteration": 100, "heap_used_mb": 10.65 }
  ],
  "recommendations": [
    "Use memory_profiler: pip install memory-profiler && python -m memory_profiler script.py",
    "Investigate suspected causes listed above",
    "..."
  ]
}

License

MIT