ACLI ROVODEV MCP Tool

A Model Context Protocol (MCP) server that bridges AI assistants with Atlassian's ACLI ROVODEV CLI, enabling seamless integration of Rovo Dev's AI-powered development capabilities into your favorite AI chat applications like Claude Desktop.

Overview

This tool creates an MCP server that allows AI assistants to interact with ACLI ROVODEV, Atlassian's command-line interface for Rovo Dev. Through this integration, you can leverage Rovo Dev's powerful AI capabilities including code analysis, generation, debugging assistance, and Atlassian ecosystem integration directly from your AI chat interface.

One-Line Setup

Get started instantly with Claude Desktop using this single command:

claude mcp add rovodev-cli -- npx -y rovodev-mcp-tool

This command automatically configures the MCP server in Claude Desktop, making ACLI ROVODEV capabilities immediately available in your AI conversations.

Key Features

• AI-Powered Code Assistance: Access Rovo Dev's intelligent code completion, debugging, and test generation capabilities
• Code Understanding: Get AI-powered code explanations, documentation generation, and codebase insights
• Atlassian Integration: Seamlessly manage Jira issues and Confluence documentation from your AI assistant
• Development Acceleration: Leverage automated refactoring, interactive debugging, and rapid prototyping
• Enterprise Security: Built-in permission controls and role-based access management
• MCP Protocol Compliance: Full compatibility with Claude Desktop and other MCP-enabled AI clients

Prerequisites

Before installing and using this tool, ensure you have the following:

Required Software

1. Node.js (version 18 or higher)

   • Download from nodejs.org
   • Verify installation: node --version

2. ACLI (Atlassian CLI) installed and configured

   • Follow Atlassian's installation guide
   • Verify installation: acli --version

Authentication Requirements

3. ACLI Authentication

   • You must be logged into ACLI with valid Atlassian credentials
   • Verify authentication: acli auth status
   • If not authenticated, run: acli auth login

4. Rovo Dev Access

   • Ensure your Atlassian account has access to Rovo Dev
   • Verify Rovo Dev CLI access: acli rovodev --help

Installation

Option 1: NPX (Recommended)

The easiest way to use this tool is via npx, which doesn't require global installation:

npx rovodev-mcp-tool

Option 2: Global Installation

Install the tool globally for easier access:

npm install -g rovodev-mcp-tool

Then run:

rovodev-mcp

Option 3: Local Development

For development or customization:

git clone https://github.com/traycerai/rovodev-mcp-tool.git
cd rovodev-mcp-tool
npm install
npm run build
npm start

Configuration

Claude Desktop Setup

To use this MCP server with Claude Desktop, add the following configuration to your Claude Desktop config file:

Location of config file:

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

Configuration:

{
  "mcpServers": {
    "rovodev": {
      "command": "npx",
      "args": [
        "-y",
        "rovodev-mcp-tool"
      ],
      "env": {
        "ROVODEV_DEBUG": "false"
      }
    }
  }
}

For global installation:

{
  "mcpServers": {
    "rovodev": {
      "command": "rovodev-mcp",
      "args": [],
      "env": {
        "ROVODEV_DEBUG": "true"
      }
    }
  }
}

Environment Variables

You can customize the behavior using these environment variables:

• ROVODEV_DEBUG: Set to "true" to enable debug logging
• ACLI_PATH: Custom path to ACLI executable (if not in PATH)
• ROVODEV_TIMEOUT: Timeout for ACLI commands in milliseconds (default: 30000)

Advanced Configuration

For more advanced setups, you can create a configuration file:

config.json:

{
  "acli": {
    "path": "/custom/path/to/acli",
    "timeout": 45000,
    "defaultArgs": ["--format", "json"]
  },
  "logging": {
    "level": "info",
    "file": "./rovodev-mcp.log"
  },
  "mcp": {
    "capabilities": {
      "tools": true,
      "resources": false,
      "prompts": true
    }
  }
}

Then reference it in your Claude Desktop config:

{
  "mcpServers": {
    "rovodev": {
      "command": "npx",
      "args": [
        "-y",
        "rovodev-mcp-tool",
        "--config",
        "/path/to/config.json"
      ]
    }
  }
}

Usage Examples

Once configured, you can use the following capabilities through your AI assistant:

Code Analysis

Analyze this TypeScript function for potential improvements:

function processData(data: any[]): any {
  return data.map(item => item.value).filter(Boolean);
}

Code Generation

Generate a React component for a user profile card with the following requirements:
- Display user avatar, name, and email
- Include edit and delete buttons
- Use TypeScript and styled-components

Documentation Generation

Generate comprehensive JSDoc comments for this class:

class UserService {
  constructor(private apiClient: ApiClient) {}
  
  async getUser(id: string): Promise<User> {
    return this.apiClient.get(`/users/${id}`);
  }
}

Jira Integration

Create a new Jira ticket for the bug I just described and assign it to the current sprint.

Code Review

Review this pull request and suggest improvements:
[paste code or provide repository context]

Available Tools

The MCP server exposes the following tools to AI assistants:

Core Development Tools

• rovodev_analyze: Analyze code for bugs, performance issues, and improvements
• rovodev_generate: Generate code based on specifications and requirements
• rovodev_document: Generate documentation for code, APIs, and projects
• rovodev_review: Perform code reviews and suggest improvements
• rovodev_refactor: Suggest and implement code refactoring

Atlassian Integration Tools

• rovodev_jira_create: Create new Jira issues and work items
• rovodev_jira_update: Update existing Jira issues
• rovodev_jira_search: Search and retrieve Jira issues
• rovodev_confluence_create: Create Confluence pages and documentation
• rovodev_confluence_update: Update existing Confluence content

Utility Tools

• rovodev_status: Check ACLI authentication and Rovo Dev availability
• rovodev_help: Get help and usage information for Rovo Dev features

Command Reference

CLI Options

rovodev-mcp-tool [options]

Options:
  --config <path>     Path to configuration file
  --debug             Enable debug logging
  --acli-path <path>  Custom path to ACLI executable
  --timeout <ms>      Timeout for ACLI commands (default: 30000)
  --help              Display help information
  --version           Display version information

MCP Protocol Commands

The server responds to standard MCP protocol messages:

• initialize: Initialize the MCP server
• list_tools: List available tools
• call_tool: Execute a specific tool
• list_resources: List available resources (if enabled)
• list_prompts: List available prompts (if enabled)

Troubleshooting

Common Issues

1. ACLI Not Found

Error: Command 'acli' not found

Solutions:

• Ensure ACLI is installed: Follow Atlassian's installation guide
• Check if ACLI is in your PATH: which acli (Unix) or where acli (Windows)
• Use the ACLI_PATH environment variable to specify custom path
• In Claude Desktop config, add the full path:

  "env": {
    "ACLI_PATH": "/full/path/to/acli"
  }

2. Authentication Issues

Error: Authentication required or Not logged in

Solutions:

• Check authentication status: acli auth status
• Log in to ACLI: acli auth login
• Ensure your account has Rovo Dev access
• Try refreshing authentication: acli auth refresh

3. Rovo Dev Access Denied

Error: Rovo Dev not available or Access denied

Solutions:

• Verify Rovo Dev access: acli rovodev --help
• Contact your Atlassian administrator to enable Rovo Dev
• Check if your organization has Rovo Dev enabled
• Ensure you're using the correct Atlassian site

4. MCP Server Connection Issues

Error: MCP server fails to start or connect

Solutions:

• Check Claude Desktop logs for detailed error messages
• Verify the configuration file syntax is valid JSON
• Ensure Node.js is installed and accessible
• Try running the tool manually: npx rovodev-mcp-tool --debug
• Check firewall and network settings

5. Timeout Issues

Error: Command timeout or Request timed out

Solutions:

• Increase timeout in configuration:

  "env": {
    "ROVODEV_TIMEOUT": "60000"
  }

• Check network connectivity to Atlassian services
• Verify ACLI is responding: acli rovodev --help

Debug Mode

Enable debug mode for detailed logging:

In Claude Desktop config:

"env": {
  "ROVODEV_DEBUG": "true"
}

Or run manually:

npx rovodev-mcp-tool --debug

Log Files

Check log files for detailed error information:

• Windows: %APPDATA%\Claude\logs\
• macOS: ~/Library/Logs/Claude/
• Linux: ~/.local/share/Claude/logs/

Getting Help

If you continue to experience issues:

1. Check the GitHub Issues page
2. Review Atlassian's ACLI documentation
3. Consult the MCP Protocol documentation
4. Create a new issue with:
   • Your operating system and version
   • Node.js version (node --version)
   • ACLI version (acli --version)
   • Complete error messages
   • Your configuration file (with sensitive data removed)

Development Setup

Prerequisites for Development

• Node.js 18+
• TypeScript 4.9+
• Git

Setting Up the Development Environment

1. Clone the repository:

   git clone https://github.com/traycerai/rovodev-mcp-tool.git
   cd rovodev-mcp-tool

2. Install dependencies:

   npm install

3. Build the project:

   npm run build

4. Run in development mode:

   npm run dev

5. Run tests:

   npm test

Project Structure

rovodev-mcp-tool/
├── src/
│   ├── cli.ts              # CLI entry point
│   ├── server.ts           # MCP server implementation
│   ├── providers/
│   │   ├── base.ts         # Base provider interface
│   │   └── rovodev.ts      # ACLI ROVODEV provider
│   ├── types/
│   │   ├── mcp.ts          # MCP protocol types
│   │   └── rovodev.ts      # ROVODEV-specific types
│   └── utils/
│       ├── logger.ts       # Logging utilities
│       ├── config.ts       # Configuration management
│       └── acli.ts         # ACLI integration utilities
├── bin/
│   └── rovodev-mcp.js      # Executable entry point
├── examples/
│   └── claude-desktop-config.json
├── package.json
├── tsconfig.json
└── README.md

Development Scripts

• npm run build: Compile TypeScript to JavaScript
• npm run dev: Run in development mode with auto-reload
• npm run test: Run the test suite
• npm run lint: Run ESLint
• npm run format: Format code with Prettier
• npm run clean: Clean build artifacts

Testing

The project includes comprehensive tests for all major components:

# Run all tests
npm test

# Run tests with coverage
npm run test:coverage

# Run tests in watch mode
npm run test:watch

# Run specific test file
npm test -- --grep "provider"

Debugging

For debugging during development:

1. Use the debug configuration:

   npm run dev -- --debug

2. Enable verbose logging:

   DEBUG=rovodev:* npm run dev

3. Use VS Code debugging:

   • Set breakpoints in TypeScript files
   • Use the provided launch configuration
   • Debug with F5

Contributing

We welcome contributions to improve the ACLI ROVODEV MCP Tool! Here's how you can help:

Ways to Contribute

• Bug Reports: Report issues you encounter
• Feature Requests: Suggest new features or improvements
• Code Contributions: Submit pull requests with fixes or enhancements
• Documentation: Improve documentation and examples
• Testing: Help test new features and report compatibility issues

Getting Started

1. Fork the repository on GitHub
2. Clone your fork locally:

   git clone https://github.com/traycerai/rovodev-mcp-tool.git

3. Create a feature branch:

   git checkout -b feature/your-feature-name

4. Make your changes and test thoroughly
5. Commit your changes:

   git commit -m "Add: your feature description"

6. Push to your fork:

   git push origin feature/your-feature-name

7. Create a Pull Request on GitHub

Development Guidelines

Code Style

• Use TypeScript for all new code
• Follow the existing code style and formatting
• Run npm run lint and npm run format before committing
• Include JSDoc comments for public APIs

Testing Requirements

• Write tests for new features and bug fixes
• Ensure all tests pass: npm test
• Maintain or improve code coverage
• Test with different ACLI versions when possible

Commit Messages

Use conventional commit format:

• feat: for new features
• fix: for bug fixes
• docs: for documentation changes
• test: for test additions/changes
• refactor: for code refactoring
• chore: for maintenance tasks

Examples:

feat: add support for Confluence page creation
fix: handle ACLI authentication timeout gracefully
docs: update installation instructions for Windows
test: add integration tests for Jira operations

Pull Request Guidelines

• Describe your changes clearly in the PR description
• Reference related issues using Fixes #123 or Closes #123
• Include tests for new functionality
• Update documentation if needed
• Keep PRs focused - one feature or fix per PR
• Respond to feedback promptly and professionally

Code of Conduct

This project follows a Code of Conduct to ensure a welcoming environment:

• Be respectful and inclusive
• Be collaborative and constructive
• Focus on the code and technical discussions
• Help others learn and grow
• Report inappropriate behavior to maintainers

Getting Help

If you need help contributing:

• Check existing issues and discussions
• Ask questions in GitHub Discussions
• Join our community channels (if available)
• Read the documentation thoroughly
• Look at existing code for examples

Recognition

Contributors will be recognized in:

• The project's CONTRIBUTORS.md file
• Release notes for significant contributions
• GitHub's contributor graphs and statistics

Thank you for helping make the ACLI ROVODEV MCP Tool better for everyone!

License

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

Support

• Documentation: GitHub Wiki
• Issues: GitHub Issues
• Discussions: GitHub Discussions
• ACLI Documentation: Atlassian Developer Docs
• MCP Protocol: Model Context Protocol

Note: This tool is not officially affiliated with Atlassian. It's a community-driven project that integrates with Atlassian's ACLI ROVODEV CLI tool.