MCP Engineering Server (ARCHIVE CUZ ANTHROPIC JUST COPY ALL MY INTERLECTUAL PROPERTY THEIR /COMMAND JUST PRETTY MUCH STOLEN ALL MY THINKING PARTTERN LOOK AT THEIR NEW RELEASE AND COMPARE IT IDEA WITH THIS REPO TIMELINE YOU WILL UNDERSTAND HOW BULLSHIT IT IS FOR ANTHROPIC TO STOLEN MY IDEA)

An MCP (Model Context Protocol) server and Claude Code plugin for AI-assisted engineering workflows.

Features

• Auto-detect project type: Supports 20+ project types (Node.js, .NET, Python, Rust, Go, Embedded, etc.)
• Security scanning: Detect secrets, API keys, and credentials before commit
• Function indexing: Index and search functions across TypeScript, Python, C#, Go, Rust, C/C++
• Duplicate detection: Find duplicate code blocks for refactoring
• Route indexing: Index API routes (Express, Flask, FastAPI, ASP.NET, Go)
• Hardware indexing: Index embedded hardware configs (STM32, ESP32, Arduino)
• Knowledge base: Extract and query learnings from completed features
• Session management: Checkpoints for context preservation across Claude sessions
• Multi-session coordination: Parallel Claude instances with file locking

Installation

Quick Install (Recommended)

npm install -g mcp-engineering-server
mcp-engineering-server install

That's it! The install command will:

1. Copy slash commands to ~/.claude/commands/ (global)
2. Register the MCP server with Claude Code

From Source

git clone https://github.com/liam1472/mcp-engineering-server.git
cd mcp-engineering-server
npm install && npm run build

# Install globally
npm link
mcp-engineering-server install

Uninstall

mcp-engineering-server uninstall
npm uninstall -g mcp-engineering-server

Slash Commands

Core Workflow

Analysis & Refactoring

Indexing

Session Management

Workflows & Scenarios

Scenario 1: New Project Setup

First time using the plugin on a project:

/eng-init                    # Auto-detect project type, create .engineering/
/eng-scan                    # Index all functions in codebase
/eng-security                # Check for any existing secrets/credentials

What happens:

• .engineering/ directory created with config
• Project type detected (e.g., web-node, embedded-stm32, python-fastapi)
• Function index built at .engineering/index/functions.yaml
• Security report generated

Scenario 2: Feature Development (Standard Flow)

Working on a new feature from start to finish:

# 1. Start feature - creates context directory
/eng-start user-authentication

# 2. Work on your code...
#    Claude assists with implementation

# 3. Before committing - validate everything
/eng-validate                # Runs: security scan + index update + status check

# 4. If security issues found
/eng-security --fix          # Auto-create .env, replace hardcoded secrets

# 5. Complete feature - archives context, extracts knowledge
/eng-done

What happens:

• Feature directory created at .engineering/features/user-authentication/
• Progress tracked in progress.yaml
• On /eng-done: archived to .engineering/archive/, learnings extracted to knowledge base

Scenario 3: Security Audit

Find and fix secrets before pushing to git:

# Scan for secrets
/eng-security

# Preview what auto-fix would do (safe, no changes)
/eng-security --fix --dry-run

# Apply fixes: create .env, replace secrets in code, backup originals
/eng-security --fix

Example output:

Security Scan Results:
  CRITICAL: 2 findings
    - src/config.ts:15 - Hardcoded API key (OPENAI_API_KEY)
    - src/db.ts:8 - Database password in connection string

  Run `/eng-security --fix` to auto-remediate

Scenario 4: Code Analysis & Refactoring

Find code quality issues:

# Find magic numbers, duplicate code, refactoring opportunities
/eng-refactor

# Preview auto-fix
/eng-refactor --fix --dry-run

# Apply fixes: extract constants, add config files
/eng-refactor --fix

# Find duplicate code blocks
/eng-duplicates

# Analyze dependencies, find circular imports
/eng-deps

Scenario 5: Search & Discovery

Find code in large codebases:

# Search functions by name or description
/eng-search "authentication"
/eng-search "parse JSON"

# Find similar code blocks (for refactoring)
/eng-index-similar "function validateUser(email, password)"

# Query knowledge base from past features
/eng-knowledge "how did we handle rate limiting"

# Index and search API routes (web projects)
/eng-routes

# Index hardware peripherals (embedded projects)
/eng-hardware

Scenario 6: Session Management

Preserve context across Claude sessions:

# Save checkpoint before ending session
/eng-checkpoint

# ... close Claude, come back later ...

# Resume from checkpoint (restores context)
/eng-resume

Scenario 7: Parallel Development (Multi-Session)

Multiple Claude instances working on same codebase:

# Terminal 1: Start session A
/eng-session-start A
/eng-lock src/auth/login.ts      # Lock file to prevent conflicts

# Terminal 2: Start session B
/eng-session-start B
/eng-lock src/auth/register.ts   # Lock different file

# Check all sessions and locks
/eng-session-status

# Sync discoveries between sessions
/eng-session-sync

# When done, unlock files
/eng-unlock src/auth/login.ts

Session status output:

Active Sessions:
  A: Working on src/auth/login.ts (locked)
  B: Working on src/auth/register.ts (locked)
  C: Inactive

Locked Files:
  - src/auth/login.ts (Session A)
  - src/auth/register.ts (Session B)

Scenario 8: Pre-Commit Review

Final checks before creating PR:

# Run full validation pipeline
/eng-pipeline                # build + lint + test + security

# Or run review checklist
/eng-review                  # Shows: security status, test status, build status

Review output:

Pre-Completion Review:
  [x] Security scan passed
  [x] Build successful
  [x] Tests passing (48/48)
  [ ] Lint warnings: 3

  Recommendation: Fix lint warnings, then ready for /eng-done

Quick Reference

Generated Structure

After running /eng-init, a .engineering/ directory is created:

.engineering/
├── config.yaml           # Project config
├── index/
│   ├── functions.yaml    # Function index
│   ├── routes.yaml       # API routes (web)
│   ├── hardware.yaml     # Hardware configs (embedded)
│   └── duplicates.yaml   # Duplicate code report
├── sessions/             # Session data (gitignore this)
├── security/
│   ├── patterns.yaml     # Detection patterns
│   └── whitelist.yaml    # False positive whitelist
├── knowledge/
│   └── base.yaml         # Extracted learnings
├── features/             # Active features
└── archive/              # Completed features

Supported Project Types

Security Patterns

The security scanner detects:

• AWS Access Keys & Secret Keys
• GCP API Keys
• Azure Storage Keys
• OpenAI / Anthropic API Keys
• JWT Tokens
• Database connection strings (MongoDB, PostgreSQL, MySQL)
• RSA/SSH Private Keys
• Hardcoded passwords

Requirements

• Node.js >= 18.0.0
• Claude Code (VS Code extension or CLI)

License

MIT