airbrake_mcp 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 554243b4d4b33ab9844e997247d1969b7fa8eb91bfb3206ad58b5d0ead331cff
+  data.tar.gz: ba8ef0c4be17a882003b4f79b795226ba18448bc89dfd0429dc408366d0968a8
+SHA512:
+  metadata.gz: 8c0d03b6f73def14080ac2ffc7a71311fc3bdd902b3be4893c217dad80a712d93660dd67590c2ab0dd5558148656eb58e96cdd7cb6072dd79d26dfca57adff21
+  data.tar.gz: 99ce5a79ea2ba8101f46a055a9ebdc65fdd2c199865619077f902bd3dad42fdbac4de0a6174dfd988852884e6b4b6cae644cd1601abce2bd4a6766672ce413ef

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [1.0.0] - 2025-01-05
+
+### Added
+- Initial release
+- MCP server with STDIO transport
+- Airbrake API client
+- Tools:
+  - `list_projects` - List all accessible Airbrake projects
+  - `list_errors` - List error groups with filtering options
+  - `get_error` - Get detailed error information with backtrace
+  - `list_notices` - List individual error occurrences
+  - `resolve_error` - Mark errors as resolved/unresolved
+  - `mute_error` - Mute/unmute error notifications

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 httplab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,142 @@
+# Airbrake MCP Server
+
+[![Gem Version](https://badge.fury.io/rb/airbrake_mcp.svg)](https://badge.fury.io/rb/airbrake_mcp)
+
+MCP (Model Context Protocol) server for Airbrake error tracking integration with Claude Code.
+
+## Features
+
+- List Airbrake projects
+- List and filter error groups
+- Get detailed error information with backtraces
+- List individual error occurrences (notices)
+- Resolve/unresolve errors
+- Mute/unmute error notifications
+
+## Requirements
+
+- Ruby 3.0+
+- Airbrake User API Key
+
+## Installation
+
+### Via RubyGems
+
+```bash
+gem install airbrake_mcp
+```
+
+### From Source
+
+```bash
+git clone https://github.com/httplab/airbrake_mcp.git
+cd airbrake_mcp
+bundle install
+```
+
+## Configuration
+
+### Getting Your API Key
+
+1. Log in to Airbrake
+2. Go to Profile Settings
+3. Find "User API Key" section
+4. Copy your key
+
+## Claude Code Integration
+
+Add to `~/.claude/settings.json` or project's `.claude/settings.local.json`:
+
+```json
+{
+  "mcpServers": {
+    "airbrake": {
+      "command": "airbrake_mcp",
+      "env": {
+        "AIRBRAKE_USER_KEY": "your_user_key",
+        "AIRBRAKE_PROJECT_ID": "123456"
+      }
+    }
+  }
+}
+```
+
+Or if installed from source:
+
+```json
+{
+  "mcpServers": {
+    "airbrake": {
+      "command": "/path/to/airbrake_mcp/exe/airbrake_mcp",
+      "env": {
+        "AIRBRAKE_USER_KEY": "your_user_key",
+        "AIRBRAKE_PROJECT_ID": "123456"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### list_projects
+List all Airbrake projects accessible to the user.
+
+### list_errors
+List error groups with filtering options.
+
+Parameters:
+- `project_id` (optional) - Project ID, uses default if not specified
+- `page` (optional) - Page number, default: 1
+- `limit` (optional) - Results per page, default: 20
+- `resolved` (optional) - Filter by resolved status (true/false)
+
+### get_error
+Get detailed information about a specific error group including backtrace.
+
+Parameters:
+- `group_id` (required) - Error group ID
+- `project_id` (optional) - Project ID
+
+### list_notices
+List individual occurrences/notices for an error group.
+
+Parameters:
+- `group_id` (required) - Error group ID
+- `project_id` (optional) - Project ID
+- `page` (optional) - Page number, default: 1
+- `limit` (optional) - Results per page, default: 10
+
+### resolve_error
+Mark an error group as resolved or unresolve it.
+
+Parameters:
+- `group_id` (required) - Error group ID
+- `project_id` (optional) - Project ID
+- `resolved` (optional) - true to resolve, false to unresolve, default: true
+
+### mute_error
+Mute or unmute an error group (suppress/enable notifications).
+
+Parameters:
+- `group_id` (required) - Error group ID
+- `project_id` (optional) - Project ID
+- `mute` (optional) - true to mute, false to unmute, default: true
+
+## Development
+
+### Running Tests
+
+```bash
+bundle exec rspec
+```
+
+### Building the Gem
+
+```bash
+gem build airbrake_mcp.gemspec
+```
+
+## License
+
+MIT

data/exe/airbrake_mcp

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'dotenv/load'
+
+require 'airbrake_mcp'
+
+# Initialize Airbrake client
+client = AirbrakeMcp::Client.new(
+  user_key: ENV.fetch('AIRBRAKE_USER_KEY') { raise 'AIRBRAKE_USER_KEY environment variable is required' },
+  project_id: ENV['AIRBRAKE_PROJECT_ID']&.to_i
+)
+
+# Create MCP server
+server = MCP::Server.new(
+  name: 'airbrake',
+  version: AirbrakeMcp::VERSION,
+  tools: [
+    AirbrakeMcp::Tools::ListProjects,
+    AirbrakeMcp::Tools::ListErrors,
+    AirbrakeMcp::Tools::GetError,
+    AirbrakeMcp::Tools::ListNotices,
+    AirbrakeMcp::Tools::ResolveError,
+    AirbrakeMcp::Tools::MuteError
+  ],
+  server_context: { client: client }
+)
+
+# Start STDIO transport
+transport = MCP::Server::Transports::StdioTransport.new(server)
+transport.open

data/lib/airbrake_mcp/client.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+module AirbrakeMcp
+  class Client
+    BASE_URL = 'https://api.airbrake.io/api/v4'
+
+    def initialize(user_key:, project_id: nil)
+      @user_key = user_key
+      @project_id = project_id
+    end
+
+    attr_reader :project_id
+
+    def projects
+      get('/projects')['projects']
+    end
+
+    def groups(project_id: @project_id, page: 1, limit: 20)
+      get("/projects/#{project_id}/groups", { page: page, limit: limit })
+    end
+
+    def group(group_id, project_id: @project_id)
+      get("/projects/#{project_id}/groups/#{group_id}")
+    end
+
+    def notices(group_id, project_id: @project_id, page: 1, limit: 10)
+      get("/projects/#{project_id}/groups/#{group_id}/notices", { page: page, limit: limit })
+    end
+
+    # Write operations
+    def resolve_group(group_id, project_id: @project_id)
+      put("/projects/#{project_id}/groups/#{group_id}/resolved")
+    end
+
+    def unresolve_group(group_id, project_id: @project_id)
+      put("/projects/#{project_id}/groups/#{group_id}/unresolved")
+    end
+
+    def mute_group(group_id, project_id: @project_id)
+      put("/projects/#{project_id}/groups/#{group_id}/muted")
+    end
+
+    def unmute_group(group_id, project_id: @project_id)
+      put("/projects/#{project_id}/groups/#{group_id}/unmuted")
+    end
+
+    private
+
+    def get(path, params = {})
+      response = connection.get(path, params.merge(key: @user_key))
+      handle_response(response)
+    end
+
+    def put(path)
+      response = connection.put("#{path}?key=#{@user_key}")
+      response.success?
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        JSON.parse(response.body)
+      when 401
+        raise AuthenticationError, 'Invalid API key'
+      when 404
+        raise NotFoundError, 'Resource not found'
+      when 429
+        raise RateLimitError, 'Rate limit exceeded'
+      else
+        raise ApiError, "API error: #{response.status} - #{response.body}"
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: BASE_URL) do |f|
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    class ApiError < StandardError; end
+    class AuthenticationError < ApiError; end
+    class NotFoundError < ApiError; end
+    class RateLimitError < ApiError; end
+  end
+end

data/lib/airbrake_mcp/formatters.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module AirbrakeMcp
+  module Formatters
+    module_function
+
+    def format_projects(projects)
+      return "No projects found" if projects.empty?
+
+      output = "Found #{projects.length} projects:\n\n"
+
+      projects.each do |project|
+        output += "  [#{project['id']}] #{project['name']}\n"
+      end
+
+      output
+    end
+
+    def format_groups(result)
+      groups = result['groups'] || []
+      total = result['count'] || groups.length
+
+      return "No error groups found" if groups.empty?
+
+      output = "Found #{total} error groups:\n\n"
+
+      groups.each do |group|
+        status = group['resolved'] ? '[RESOLVED]' : '[OPEN]'
+        muted = group['muted'] ? ' (muted)' : ''
+        error = group['errors']&.first || {}
+
+        output += "#{status}#{muted} ##{group['id']}\n"
+        output += "  Type: #{error['type']}\n"
+        output += "  Message: #{truncate(error['message'], 100)}\n"
+        output += "  Count: #{group['noticeCount']} occurrences\n"
+        output += "  Last seen: #{group['lastNoticeAt']}\n"
+        output += "  Environment: #{group.dig('context', 'environment') || 'N/A'}\n"
+        output += "\n"
+      end
+
+      output
+    end
+
+    def format_group_detail(group)
+      error = group['errors']&.first || {}
+
+      output = "Error Group ##{group['id']}\n"
+      output += "=" * 50 + "\n\n"
+
+      output += "Status: #{group['resolved'] ? 'Resolved' : 'Open'}\n"
+      output += "Muted: #{group['muted'] ? 'Yes' : 'No'}\n"
+      output += "Type: #{error['type']}\n"
+      output += "Message: #{error['message']}\n"
+      output += "Total occurrences: #{group['noticeCount']}\n"
+      output += "First seen: #{group['createdAt']}\n"
+      output += "Last seen: #{group['lastNoticeAt']}\n"
+      output += "Environment: #{group.dig('context', 'environment') || 'N/A'}\n"
+
+      if group['lastDeployAt']
+        output += "Last deploy: #{group['lastDeployAt']}\n"
+      end
+
+      output += "\n"
+      output += "Backtrace:\n"
+      output += "-" * 30 + "\n"
+
+      backtrace = error['backtrace'] || []
+      backtrace.first(15).each_with_index do |frame, i|
+        file = frame['file'] || '?'
+        line = frame['line'] || '?'
+        func = frame['function'] || '?'
+        output += "  #{i + 1}. #{file}:#{line} in `#{func}`\n"
+      end
+
+      if backtrace.length > 15
+        output += "  ... and #{backtrace.length - 15} more frames\n"
+      end
+
+      output
+    end
+
+    def format_notices(result)
+      notices = result['notices'] || []
+
+      return "No notices found" if notices.empty?
+
+      output = "Error occurrences:\n\n"
+
+      notices.each_with_index do |notice, i|
+        error = notice['errors']&.first || {}
+
+        output += "#{i + 1}. Notice ##{notice['id']}\n"
+        output += "   Time: #{notice['createdAt']}\n"
+        output += "   Type: #{error['type']}\n"
+        output += "   Message: #{truncate(error['message'], 80)}\n"
+
+        context = notice['context'] || {}
+        if context['url']
+          output += "   URL: #{context['url']}\n"
+        end
+        if context['userAgent']
+          output += "   User-Agent: #{truncate(context['userAgent'], 60)}\n"
+        end
+        if context['userId']
+          output += "   User ID: #{context['userId']}\n"
+        end
+
+        output += "\n"
+      end
+
+      output
+    end
+
+    def truncate(str, length)
+      return '' if str.nil?
+      str.length > length ? "#{str[0...length]}..." : str
+    end
+  end
+end

data/lib/airbrake_mcp/tools/get_error.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module AirbrakeMcp
+  module Tools
+    class GetError < MCP::Tool
+      tool_name "get_error"
+      description "Get detailed information about a specific error group including backtrace"
+
+      input_schema(
+        properties: {
+          group_id: { type: "integer", description: "Error group ID" },
+          project_id: { type: "integer", description: "Project ID (uses default if not specified)" }
+        },
+        required: ["group_id"]
+      )
+
+      def self.call(group_id:, project_id: nil, server_context:)
+        client = server_context[:client]
+        pid = project_id || client.project_id
+
+        unless pid
+          return MCP::Tool::Response.new([
+            MCP::Content::Text.new("Error: No project_id specified and no default configured")
+          ], error: true)
+        end
+
+        group = client.group(group_id, project_id: pid)
+
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new(Formatters.format_group_detail(group))
+        ])
+      rescue Client::NotFoundError
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: Error group #{group_id} not found")
+        ], error: true)
+      rescue Client::ApiError => e
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: #{e.message}")
+        ], error: true)
+      end
+    end
+  end
+end

data/lib/airbrake_mcp/tools/list_errors.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module AirbrakeMcp
+  module Tools
+    class ListErrors < MCP::Tool
+      tool_name "list_errors"
+      description "List error groups from Airbrake with filtering options"
+
+      input_schema(
+        properties: {
+          project_id: { type: "integer", description: "Project ID (uses default if not specified)" },
+          page: { type: "integer", description: "Page number (default: 1)" },
+          limit: { type: "integer", description: "Results per page (default: 20, max: 100)" },
+          resolved: { type: "boolean", description: "Filter by resolved status (true/false)" }
+        },
+        required: []
+      )
+
+      def self.call(project_id: nil, page: 1, limit: 20, resolved: nil, server_context:)
+        client = server_context[:client]
+        pid = project_id || client.project_id
+
+        unless pid
+          return MCP::Tool::Response.new([
+            MCP::Content::Text.new("Error: No project_id specified and no default configured")
+          ], error: true)
+        end
+
+        result = client.groups(project_id: pid, page: page, limit: limit)
+
+        # Client-side filtering for resolved status if specified
+        if !resolved.nil? && result['groups']
+          result['groups'] = result['groups'].select { |g| g['resolved'] == resolved }
+        end
+
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new(Formatters.format_groups(result))
+        ])
+      rescue Client::ApiError => e
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: #{e.message}")
+        ], error: true)
+      end
+    end
+  end
+end

data/lib/airbrake_mcp/tools/list_notices.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module AirbrakeMcp
+  module Tools
+    class ListNotices < MCP::Tool
+      tool_name "list_notices"
+      description "List individual occurrences/notices for an error group"
+
+      input_schema(
+        properties: {
+          group_id: { type: "integer", description: "Error group ID" },
+          project_id: { type: "integer", description: "Project ID (uses default if not specified)" },
+          page: { type: "integer", description: "Page number (default: 1)" },
+          limit: { type: "integer", description: "Results per page (default: 10)" }
+        },
+        required: ["group_id"]
+      )
+
+      def self.call(group_id:, project_id: nil, page: 1, limit: 10, server_context:)
+        client = server_context[:client]
+        pid = project_id || client.project_id
+
+        unless pid
+          return MCP::Tool::Response.new([
+            MCP::Content::Text.new("Error: No project_id specified and no default configured")
+          ], error: true)
+        end
+
+        result = client.notices(group_id, project_id: pid, page: page, limit: limit)
+
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new(Formatters.format_notices(result))
+        ])
+      rescue Client::NotFoundError
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: Error group #{group_id} not found")
+        ], error: true)
+      rescue Client::ApiError => e
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: #{e.message}")
+        ], error: true)
+      end
+    end
+  end
+end

data/lib/airbrake_mcp/tools/list_projects.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AirbrakeMcp
+  module Tools
+    class ListProjects < MCP::Tool
+      tool_name "list_projects"
+      description "List all Airbrake projects accessible to the user"
+
+      def self.call(server_context:)
+        client = server_context[:client]
+        projects = client.projects
+
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new(Formatters.format_projects(projects))
+        ])
+      rescue Client::ApiError => e
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: #{e.message}")
+        ], error: true)
+      end
+    end
+  end
+end

data/lib/airbrake_mcp/tools/mute_error.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AirbrakeMcp
+  module Tools
+    class MuteError < MCP::Tool
+      tool_name "mute_error"
+      description "Mute or unmute an error group (suppress/enable notifications)"
+
+      input_schema(
+        properties: {
+          group_id: { type: "integer", description: "Error group ID" },
+          project_id: { type: "integer", description: "Project ID (uses default if not specified)" },
+          mute: { type: "boolean", description: "true to mute, false to unmute (default: true)" }
+        },
+        required: ["group_id"]
+      )
+
+      def self.call(group_id:, project_id: nil, mute: true, server_context:)
+        client = server_context[:client]
+        pid = project_id || client.project_id
+
+        unless pid
+          return MCP::Tool::Response.new([
+            MCP::Content::Text.new("Error: No project_id specified and no default configured")
+          ], error: true)
+        end
+
+        if mute
+          client.mute_group(group_id, project_id: pid)
+          action = "muted"
+        else
+          client.unmute_group(group_id, project_id: pid)
+          action = "unmuted"
+        end
+
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error group ##{group_id} #{action}")
+        ])
+      rescue Client::NotFoundError
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: Error group #{group_id} not found")
+        ], error: true)
+      rescue Client::ApiError => e
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: #{e.message}")
+        ], error: true)
+      end
+    end
+  end
+end

data/lib/airbrake_mcp/tools/resolve_error.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AirbrakeMcp
+  module Tools
+    class ResolveError < MCP::Tool
+      tool_name "resolve_error"
+      description "Mark an error group as resolved or unresolve it"
+
+      input_schema(
+        properties: {
+          group_id: { type: "integer", description: "Error group ID" },
+          project_id: { type: "integer", description: "Project ID (uses default if not specified)" },
+          resolved: { type: "boolean", description: "true to resolve, false to unresolve (default: true)" }
+        },
+        required: ["group_id"]
+      )
+
+      def self.call(group_id:, project_id: nil, resolved: true, server_context:)
+        client = server_context[:client]
+        pid = project_id || client.project_id
+
+        unless pid
+          return MCP::Tool::Response.new([
+            MCP::Content::Text.new("Error: No project_id specified and no default configured")
+          ], error: true)
+        end
+
+        if resolved
+          client.resolve_group(group_id, project_id: pid)
+          action = "resolved"
+        else
+          client.unresolve_group(group_id, project_id: pid)
+          action = "unresolved"
+        end
+
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error group ##{group_id} marked as #{action}")
+        ])
+      rescue Client::NotFoundError
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: Error group #{group_id} not found")
+        ], error: true)
+      rescue Client::ApiError => e
+        MCP::Tool::Response.new([
+          MCP::Content::Text.new("Error: #{e.message}")
+        ], error: true)
+      end
+    end
+  end
+end

data/lib/airbrake_mcp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AirbrakeMcp
+  VERSION = '1.0.0'
+end

data/lib/airbrake_mcp.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+require_relative 'airbrake_mcp/version'
+require_relative 'airbrake_mcp/client'
+require_relative 'airbrake_mcp/formatters'
+require_relative 'airbrake_mcp/tools/list_projects'
+require_relative 'airbrake_mcp/tools/list_errors'
+require_relative 'airbrake_mcp/tools/get_error'
+require_relative 'airbrake_mcp/tools/list_notices'
+require_relative 'airbrake_mcp/tools/resolve_error'
+require_relative 'airbrake_mcp/tools/mute_error'

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: airbrake_mcp
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- httplab
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Model Context Protocol (MCP) server for Claude Code integration with
+  Airbrake error tracking
+email:
+- info@httplab.ru
+executables:
+- airbrake_mcp
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- exe/airbrake_mcp
+- lib/airbrake_mcp.rb
+- lib/airbrake_mcp/client.rb
+- lib/airbrake_mcp/formatters.rb
+- lib/airbrake_mcp/tools/get_error.rb
+- lib/airbrake_mcp/tools/list_errors.rb
+- lib/airbrake_mcp/tools/list_notices.rb
+- lib/airbrake_mcp/tools/list_projects.rb
+- lib/airbrake_mcp/tools/mute_error.rb
+- lib/airbrake_mcp/tools/resolve_error.rb
+- lib/airbrake_mcp/version.rb
+homepage: https://github.com/httplab/airbrake_mcp
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/httplab/airbrake_mcp
+  source_code_uri: https://github.com/httplab/airbrake_mcp
+  changelog_uri: https://github.com/httplab/airbrake_mcp/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: MCP server for Airbrake error tracking
+test_files: []