npm package: @jaggerxtrm/rovodev-mcp-tool
Description: Model Context Protocol server for acli rovodev integration
Latest version: 1.1.0

# Rovodev MCP Tool

Model Context Protocol server for Atlassian Rovo Dev CLI integration. This tool enables AI assistants like Claude to leverage Rovo Dev's powerful code analysis and capabilities through the MCP protocol.

Rovo Dev is a comprehensive AI coding assistant that already includes built-in MCP support. This tool allows Rovo Dev to be used as an external tool from other MCP-compatible AI assistants, creating a bridge between different AI tools.

## Features

- **Large Context Windows**: Leverage Rovo Dev's powerful AI capabilities for analyzing large files and entire codebases
- **Access to Premium Models**: Pre-configured with premium Anthropic models (Sonnet 4, Opus) and GPT-5 for advanced reasoning
- **File Analysis**: Use `@filename` or `@directory` syntax to include file contents in your queries
- **Shadow Mode**: Test changes safely on temporary workspace copies before applying to actual files
- **MCP Protocol**: Seamless integration with MCP-compatible AI assistants
- **Built-in Project Awareness**: Rovo Dev CLI's built-in workspace management and context awareness

## Prerequisites

- Node.js v16 or higher
- acli rovodev installed and configured (Atlassian Rovo Dev CLI)

## Installation

### Prerequisites

First, ensure you have Rovo Dev CLI installed and configured:

```bash
# Follow Rovo Dev installation instructions to install acli rovodev
# Configure your models and authentication in ~/.rovodev/config.yml
```

### Quick Setup (Easiest - Recommended)

Use Claude Code's built-in MCP installer:

```bash
claude mcp add rovodev-cli -- npx -y @jaggerxtrm/rovodev-mcp-tool
```

This single command configures everything automatically!

### Manual Configuration for Rovo Dev

Since Rovo Dev already has MCP support, you can add this tool to your existing Rovo Dev configuration:

Edit `~/.rovodev/config.yml` and add to the `allowedMcpServers` list:
```yaml
mcp:
  allowedMcpServers:
  - stdio:npx:-y @jaggerxtrm/rovodev-mcp-tool  # Add this line
```

Or add to `~/.rovodev/mcp.json`:
```json
{
  "mcpServers": {
    "...": "...",
    "rovodev-cli": {
      "command": "npx",
      "args": [
        "-y",
        "@jaggerxtrm/rovodev-mcp-tool"
      ]
    }
  }
}
```

### From Source (Development)

1. Clone and install dependencies:
```bash
git clone <repo-url>
cd rovodev-mcp-tool
npm install
```

2. Build the project:
```bash
npm run build
```

3. Link locally:
```bash
npm link
```

## Available Tools

### ask-rovodev

The main tool for interacting with Rovodev AI.

**Parameters:**
- `prompt` (required): Your question or instruction
  - Use `@filename` to include a file's contents
  - Use `@directory` to include all files in a directory
- `yolo` (optional): Enable YOLO mode to auto-approve all operations
- `shadow` (optional): Enable shadow mode for safe changes on temporary workspace copy
- `verbose` (optional): Enable verbose tool output
- `restore` (optional): Continue last session instead of starting new one

**Examples:**
```javascript
// Analyze a specific file
{
  "prompt": "@src/main.ts Explain what this code does"
}

// Analyze entire codebase
{
  "prompt": "@src/ Summarize the architecture of this codebase"
}

// Use shadow mode for safe changes
{
  "prompt": "Refactor the authentication system",
  "shadow": true
}

// Use YOLO mode for quick iterations
{
  "prompt": "Add error handling to all API endpoints",
  "yolo": true
}
```

### ping

Simple echo test to verify the connection.

**Parameters:**
- `prompt` (optional): Message to echo (defaults to "Rovodev Pong!")

### Help

Display Rovodev CLI help information.

**Parameters:** None

## Configuration

This tool uses Rovo Dev's default model configuration. Models are configured in Rovo Dev CLI itself (typically in `~/.rovodev/config.yml`).

## Usage with Claude Code

Once installed as an MCP server, you can use it within Claude Code:

```
Ask Rovodev to analyze the authentication system in @src/auth/
```

Claude will automatically use the ask-rovodev tool with the appropriate parameters.

## Project Structure

```
rovodev-mcp-tool/
├── src/
│   ├── index.ts              # MCP server entry point
│   ├── constants.ts          # Configuration and constants
│   ├── tools/
│   │   ├── registry.ts       # Tool registration system
│   │   ├── ask-rovodev.tool.ts  # Main Rovodev interaction tool
│   │   ├── simple-tools.ts   # Utility tools (ping, help)
│   │   └── index.ts          # Tool exports
│   └── utils/
│       ├── commandExecutor.ts # Command execution utility
│       ├── rovodevExecutor.ts    # Rovodev CLI wrapper
│       └── logger.ts          # Logging utility
├── package.json
├── tsconfig.json
└── README.md
```

## How It Works

1. The MCP server listens for tool calls via stdio transport
2. When a tool is called, the server validates the arguments using Zod schemas
3. For `ask-rovodev`, the prompt is passed to the acli rovodev run command with appropriate flags
4. File references (`@filename`) are processed by Rovo Dev's built-in file processing
5. Output from Rovo Dev is captured and returned to the MCP client
6. The tool integrates with Rovo Dev's existing configuration and model settings

## Troubleshooting

### "acli rovodev not found"

Make sure the acli rovodev command is installed and available in your PATH.

### "Command timed out"

For very large files or codebases, the analysis may take longer than the default 10-minute timeout. Consider:
- Using `.rovodevignore` to exclude unnecessary files
- Breaking down large queries into smaller chunks
- Using `approvalMode: "plan"` to analyze without executing

### "Invalid tool arguments"

Check that your arguments match the tool schema. Use the `Help` tool to see available options.

## License

MIT

## Contributing

Contributions are welcome! Please feel free to submit issues or pull requests.

## Credits

Inspired by [qwen-mcp-tool](https://github.com/QwenLM/qwen-mcp-tool) and [gemini-mcp-tool](https://github.com/jamubc/gemini-mcp-tool).