Keeping you up to date on AI and Model Context Protocol (MCP)

MCP Code Analysis

A powerful codebase analysis toolkit that leverages the Model Context Protocol (MCP) for AI-assisted code understanding and transformation.

Features

Code Analysis: Parse and analyze codebases with abstract syntax trees
Context Generation: Create rich contextual information for AI models
Tool Integration: Built on the MCP SDK for seamless AI tool integration
Extensible Architecture: Plugin-based system for custom analyzers

Requirements

Node.js 18+
NPM 9+
Redis (optional, only required for production environments)

Installation

## Clone the repository
git clone https://github.com/yourusername/mcp-codeanalysis.git
cd mcp-codeanalysis

## Install dependencies
npm install

## Build the project
npm run build

Redis Configuration (Optional)

Redis is used for session storage in production environments. For development and testing, the system will automatically fall back to an in-memory session store if Redis is not available.

Note: There is a known issue with Redis connectivity where operations may fail even when Redis is running. See the "Tech Debt" section in plan.md for details. For now, you can use the ./use-memory-session.sh script to run the server with the memory session store. For more information, see Redis Troubleshooting Guide.

To install Redis:

## Ubuntu/Debian
sudo apt-get install redis-server

## macOS
brew install redis

## Windows (using WSL is recommended)
## For native Windows, download from https://redis.io/download

By default, the application tries to connect to Redis at redis://localhost:6379. You can configure the Redis connection using environment variables:

## Set custom Redis URL
export REDIS_URL=redis://custom-host:6379

## Force memory session store even if Redis is available
export FORCE_MEMORY_SESSION=true

Development

## Run in development mode
npm run dev

## Run tests
npm test

## Run linting
npm run lint

Usage

## Start the MCP server
npm start

## Run CLI tool
node ./tools/mcp-stdio-client.js --task "Analyze dependencies" --files "src/*.ts"

Documentation

License

MIT

CodeAnalysis MCP Server

A comprehensive Model Context Protocol (MCP) server for advanced code analysis, providing tools and insights through an extensible architecture.

🚀 Features

Basic Code Analysis: Syntax and structure analysis
Code Metrics: Complexity, line counts, and code quality metrics
Dependency Analysis: Package and import relationship visualization
Knowledge Graph: Code relationships visualization and querying
Memory System: Store and retrieve insights about codebases
Visualizations: Generate diagrams in multiple formats (Mermaid, DOT, ASCII)
Socio-Technical Analysis: Understand team and code relationships
Multi-Repository Analysis: Cross-repository relationship analysis
Evolution Planning: Code improvement recommendations
Live Watching: Monitor code changes in real-time
IDE Integration: Tools for editor integration
Developer Tools: Enhanced AI-assisted development workflow support

📋 Prerequisites

Node.js 18+
npm or yarn
Redis (optional for development, recommended for production)

🛠️ Installation

## Clone the repository
git clone https://github.com/your-username/codeanalysis-mcp.git
cd codeanalysis-mcp

## Install dependencies
pnpm install

## Build the project
pnpm build

🖥️ Usage

The CodeAnalysis MCP server can be used in two ways:

1. As an MCP Server

## Start the MCP server
pnpm start

This starts the MCP server that can be connected to by any MCP client like Claude Desktop, Cursor, or others.

2. Using the CLI

The project includes a comprehensive CLI for direct interaction:

## Get help
pnpm run cli --help

## Analyze a repository or directory
pnpm run cli analyze repo ./src

## Check code quality
pnpm run cli quality analyze ./src

3. Using Developer Tools for AI-Assisted Development

The project includes special tools designed to enhance AI-assisted development:

## Generate code context for AI assistants
node tools/ai-dev-helper.js --task="Implement new feature" --search="related functionality"

## Run example client
node examples/dev-tools-client.js

See the Developer Tools Guide for detailed information.

📊 Example Commands

Basic Analysis

## Analyze a local directory
pnpm run cli analyze repo ./src

## Analyze a specific file
pnpm run cli analyze file ./src/server.ts

Code Metrics

## Get code metrics with function details
pnpm run cli metrics analyze ./src --functions

## Save metrics to a file
pnpm run cli metrics analyze ./src -o metrics-report.json

Dependency Analysis

## Analyze dependencies in Mermaid format
pnpm run cli dependencies analyze ./src -f mermaid -o deps.mmd

## Visualize dependencies
pnpm run cli visualize dependencies -p ./src --format mermaid

Code Quality

## Run quality analysis
pnpm run cli quality analyze ./src

## Generate HTML report
pnpm run cli quality analyze ./src --html -o quality-report.html

Knowledge Graph

## Build knowledge graph
pnpm run cli knowledge build ./src

## Query the knowledge graph
pnpm run cli knowledge query ./src "type:function AND complexity>5"

## Export as diagram
pnpm run cli knowledge export ./src -f mermaid

Insights & Memory

## Store an insight
pnpm run cli insights store -r ./src -t code-pattern -c "Refactoring opportunity"

## Retrieve insights
pnpm run cli insights retrieve -r ./src

Developer Tools

## Prepare context for AI interactions
node tools/ai-dev-helper.js --task="Fix authentication bug" --files="src/auth/*.ts" --search="login"

## Use with AI prompts
## Copy content from the generated ai-context.json file into your AI assistant prompt
## or use the template in templates/ai-prompt-template.md

🏗️ Architecture

The project follows the MCP architecture with these components:

MCP Server: Core server implementation using the MCP protocol
Analysis Features: Modular code analysis capabilities
CLI: Command-line interface for direct interaction
Transport Layer: Communication mechanism (stdio by default)

🔌 Integration with MCP Clients

This server is compatible with any MCP-compliant client, including:

Claude Desktop App
Cursor Editor
Continue
Other MCP-compatible tools

📝 Path Specification

Commands accept paths in various formats:

Local directory: ./src or /absolute/path/to/dir
Local file: ./src/file.ts or /path/to/file.ts
Repository URL: https://github.com/username/repo

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

MCP SDK State Management Architecture

This project implements stateful tools for the Model Context Protocol (MCP) SDK, providing a framework for building tools that maintain context between invocations.

Architecture Overview

The state management architecture is organized into several modular components:

src/state/
├── helpers/
│   └── statefulTool.ts       # Main entry point for stateful tool creation
├── machines/
│   └── toolMachine.ts        # XState machine for tool execution flow
├── services/
│   ├── toolService.ts        # Core execution service for tools
│   ├── redisToolExecutionService.ts  # Distributed execution service
│   ├── redisSessionStore.ts  # Redis-based session persistence
│   └── types.ts              # Shared type definitions

Core Components

Stateful Tool Helper (`statefulTool.ts`)

The central integration point with the MCP SDK, providing:

Tool registration with session management
MCP-compliant response formatting
In-memory session management
Helper functions for session access and manipulation

// Creating a stateful tool with state persistence
createStatefulTool(server, "my-tool", schema, handler);

// With description
createStatefulTool(server, "my-tool", "My stateful tool", schema, handler);

Tool Machine (`toolMachine.ts`)

XState-based state machine that defines the execution flow for tools:

State transitions (idle, toolSelected, parametersSet, executing, etc.)
Context management for parameters, results, and history
Error handling and recovery paths

This component delegates session management to the statefulTool implementation.

Tool Service (`toolService.ts`)

Core execution service that coordinates tool state transitions:

Manages tool selection, parameter validation, and execution
Tracks execution history
Handles execution results and errors

Types (`types.ts`)

Shared type definitions that ensure consistency across the state management system:

SessionData: Structure for storing tool state
SessionStore: Interface for session storage implementations
ExecutionResult: Standard response format for tools

Integration with MCP SDK

The architecture integrates with the MCP SDK by:

Extending the tool registration pattern with state management
Maintaining compatibility with MCP's response format
Providing session and context tracking for stateful operations

Usage Example

import { createServer } from "@modelcontextprotocol/sdk";
import { createStatefulTool } from "./state/helpers/statefulTool";
import { z } from "zod";

const server = createServer();

// Register a stateful tool
createStatefulTool(
  server,
  "counter",
  "A tool that maintains a count between invocations",
  {
    action: z.enum(["increment", "decrement", "reset"]),
  },
  async (params) => {
    // Get session ID from params (or a new one will be created)
    const sessionId = params.sessionId;

    // Process the action
    let count = 0;

    // Tool logic with state manipulation...

    return { count };
  }
);

server.listen(3000);

Distributed State Management

For distributed environments, the Redis-based implementations provide:

Session persistence across server restarts
Distributed locking for concurrent access
TTL-based session cleanup
Error handling for network/connection issues

Testing

The components include comprehensive test suites to verify:

Tool state transitions
Session management
Error handling and recovery
Response formatting
Distributed operation (with Redis)

AI Development Tools

The CodeAnalysis MCP Server provides specialized tools for AI-assisted development. These tools help collect code context that can be fed to AI systems for more effective assistance.

Client Scripts

The repository includes several client scripts in the tools/ directory:

HTTP Client (tools/http-client.js): Connects to the MCP server via HTTP transport (default).

node tools/http-client.js --task "Your task description" --files "src/features/*.ts" --search "session"

Raw Client (tools/mcp-raw-client.js): A simpler client that only captures server information.
```
node tools/mcp-raw-client.js --task "Your task description"
```

Simple Client (tools/simple-client.js): Communicates with the server via stdio.

node tools/simple-client.js --task "Your task description" --files "src/features/*.ts"

All client scripts generate an ai-context.json file in the project root. This file contains valuable context about your codebase that can be shared with AI assistants to provide better-informed responses.

Prompt Template

A prompt template for AI assistants is available at templates/ai-prompt-template.md. This template helps structure your requests to AI assistants with proper context from the MCP tools.

Server Transport Modes

The MCP server supports two transport modes:

HTTP Transport (default): Runs on port 3000 by default. Best for client-server architecture.
Stdio Transport: For direct process communication. Set the STDIO_TRANSPORT=true environment variable to enable.

Session Storage Architecture

MCP Code Analysis now features a modular session store architecture with automatic backend detection:

Flexible Storage: Automatically switches between Redis and in-memory storage
Development Friendly: Run without Redis during development
Production Ready: Use Redis for persistence in production environments
Automatic Fallback: Gracefully falls back to memory storage when Redis is unavailable

For more details, see the Session Store Architecture documentation.

Requirements

Node.js 18+
npm or yarn
Redis (optional for development, recommended for production)

MCP Code Analysis

Features

Requirements

Installation

Redis Configuration (Optional)

Development

Usage

Documentation

License

CodeAnalysis MCP Server

🚀 Features

📋 Prerequisites

🛠️ Installation

🖥️ Usage

1. As an MCP Server

2. Using the CLI

3. Using Developer Tools for AI-Assisted Development

📊 Example Commands

Basic Analysis

Code Metrics

Dependency Analysis

Code Quality

Knowledge Graph

Insights & Memory

Developer Tools

🏗️ Architecture

🔌 Integration with MCP Clients

📝 Path Specification

🤝 Contributing

📄 License

MCP SDK State Management Architecture

Architecture Overview

Core Components

Stateful Tool Helper (statefulTool.ts)

Tool Machine (toolMachine.ts)

Tool Service (toolService.ts)

Types (types.ts)

Integration with MCP SDK

Usage Example

Distributed State Management

Testing

AI Development Tools

Client Scripts

Prompt Template

Server Transport Modes

Session Storage Architecture

Requirements

Stateful Tool Helper (`statefulTool.ts`)

Tool Machine (`toolMachine.ts`)

Tool Service (`toolService.ts`)

Types (`types.ts`)