open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/joaomj-code-reviewer-mcp
Description: A Model Context Protocol server
Latest version: 0.1.0

# Code Reviewer MCP Server

A GitHub Pull Request Code Review server using Model Context Protocol

This MCP server provides automated code review capabilities for GitHub pull requests by integrating with OpenRouter's AI models.

## Features

- Automated code reviews for GitHub pull requests
- Detailed feedback on code quality, style and potential issues
- Integration with OpenRouter's AI models (currently using Gemini 2.5 Pro)
- Comprehensive logging for debugging

## Requirements

-   A GitHub Personal Access Token (PAT) with `repo` scope for private repositories or `public_repo` scope for public repositories. This PAT is required to fetch pull request data.
-   An OpenRouter API Key.

## Current Limitations

⚠️ **Important**: Currently this server only works with:
- Open pull requests (not draft PRs)

## Installation

1. Clone this repository:
```bash
git clone https://github.com/joaomj/code-reviewer-mcp.git
cd code-reviewer-mcp
```

2. Install dependencies:
```bash
npm install
```

3. Set required environment variables:
```bash
export GITHUB_PAT=your_github_personal_access_token
export OPENROUTER_API_KEY=your_openrouter_api_key
```

4. Build the server:
```bash
npm run build
```

## Usage

To start the MCP server:
```bash
node build/index.js
```

The server will be available to any MCP-compatible client (like Claude Desktop).

## Configuration

Add to your MCP client configuration:

```json
{
  "mcpServers": {
    "code-reviewer-mcp": {
      "command": "node",
      "args": ["/path/to/code-reviewer-mcp/build/index.js"],
      "env": {
        "GITHUB_PAT": "your_github_token",
        "OPENROUTER_API_KEY": "your_openrouter_key"
      }
    }
  }
}
```

## Development

For development with auto-rebuild:
```bash
npm run watch
```

To run tests:
```bash
npm test
```

## Debugging

Use the built-in logging which outputs to stderr with detailed information about:
- GitHub API requests
- OpenRouter API calls
- Processing steps
- Any errors encountered

For more advanced debugging, use the MCP Inspector:
```bash
npm run inspector
```

## Next Steps

Planned improvements and features:

- [ ] Draft pull request analysis
- [ ] Customizable review templates
- [ ] Support for multiple AI models (OpenAI, Claude, etc.)
- [ ] File-specific feedback
- [ ] Rate limiting and caching

## Contributing

Suggestions are welcome. **Please open an issue first** to discuss what you would like to change.
npm package: @iflow-mcp/johnlindquist-mcp-tools
Description: This is a modular toolkit for creating MCP (Model Context Protocol) tools. Each tool is a standalone executable that can be used independently.
Latest version: 1.0.0

# MCP Tools

This is a modular toolkit for creating MCP (Model Context Protocol) tools. Each tool is a standalone executable that can be used independently.

https://github.com/modelcontextprotocol/typescript-sdk

## Prerequisites

- Node.js 23+ (or Bun/Deno/Anything that supports running .ts files)
- Bun (for building executables)

## Installing Bun

If you don't have Bun installed, you can install it using one of the following methods:

### macOS and Linux

```bash
# Using curl (recommended)
curl -fsSL https://bun.sh/install | bash

# Using Homebrew
brew install oven-sh/bun/bun

# Using npm
npm install -g bun
```

### Windows

```bash
# Using PowerShell
powershell -c "irm bun.sh/install.ps1|iex"

# Using npm
npm install -g bun

# Using Scoop
scoop install bun
```

Verify your installation by running:

```bash
bun --version
```

## Installation

```bash
pnpm install
```

## Project Structure

This project demonstrates a modular approach to building MCP tools:

- Each tool is defined in its own TypeScript file in the `src` directory
- Each tool can be built into a standalone executable in the `bin` directory
- The main `index.ts` provides a simple "Hello World" example

### Available Tools

1. **Hello** (`src/index.ts`): A simple greeting tool
2. **Weather** (`src/weather.ts`): Get weather alerts for a state
3. **Blog** (`src/blog.ts`): Tools for blog post creation and frontmatter generation

## Creating Your Own Tool

To create a new tool:

1. Create a new TypeScript file in the `src` directory (e.g., `src/mytool.ts`)
2. Use the existing tools as templates
3. Add a build script to `package.json`:

```json
"build:mytool": "mkdir -p bin && bun build src/mytool.ts --compile --minify --sourcemap --outfile bin/mcp-mytool"
```

4. Update the `build:all` script to include your new tool

## Usage

### Building Executables

```bash
# Build all tools
pnpm build

# Build a specific tool
pnpm build:hello
pnpm build:weather
pnpm build:blog
```

The resulting executables will be in the `bin` directory and can be run directly:

```bash
./bin/mcp-hello
./bin/mcp-weather
./bin/mcp-blog
```

## Cursor Notes

When using these tools with Cursor, always use the full path to the executable:

```
/path/to/your/project/bin/mcp-hello
/path/to/your/project/bin/mcp-weather
/path/to/your/project/bin/mcp-blog
```

Alternatively, you can run the TypeScript files directly with Node:

```
/path/to/node ~/path/to/project/src/index.ts
```

## Testing

```bash
# Run all tests
pnpm test

# Run tests in watch mode
pnpm test:watch

# Run tests with coverage
pnpm test:coverage
```