rosett-ai 1.3.3

data/lib/rosett_ai/mcp/settings/trust_manager.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Settings
+      # Manages trust sources for MCP server installation.
+      #
+      # Trust sources define which domains are approved for
+      # MCP server installation. Prevents untrusted servers
+      # from being silently added to configuration.
+      #
+      # @author hugo
+      # @author claude
+      class TrustManager
+        CONFIG_DIR = '.config/rosett-ai/mcp'
+        USER_TRUST_FILE = 'user_trust.yml'
+
+        # @param config_dir [Pathname, nil] override config directory
+        # @param defaults_path [Pathname, nil] override default trust sources file
+        def initialize(config_dir: nil, defaults_path: nil)
+          @config_dir = config_dir || Pathname.new(Dir.home).join(CONFIG_DIR)
+          @defaults_path = defaults_path || RosettAi.root.join('conf', 'mcp', 'trust.yml')
+        end
+
+        # Lists all trusted sources (default + user-added).
+        #
+        # @return [Array<Hash>] trust source entries with :domain, :type, :description
+        def list
+          default_sources + user_sources
+        end
+
+        # Checks whether a domain is trusted.
+        #
+        # @param domain [String] domain to check
+        # @return [Boolean]
+        def trusted?(domain)
+          normalized = normalize_domain(domain)
+          list.any? { |source| normalize_domain(source[:domain]) == normalized }
+        end
+
+        # Validates whether a URI originates from a trusted source.
+        #
+        # @param uri [String] URI to validate
+        # @return [Hash] result with :trusted, :domain, :source_type
+        def validate_uri(uri)
+          domain = extract_domain(uri)
+          source = find_source(domain)
+
+          if source
+            { trusted: true, domain: domain, source_type: source[:type] }
+          else
+            { trusted: false, domain: domain, source_type: nil }
+          end
+        end
+
+        # Adds a user-trusted domain.
+        #
+        # @param domain [String] domain to trust
+        # @param description [String] optional description
+        # @return [void]
+        def add_trust(domain, description: 'User-trusted domain')
+          sources = user_sources
+          normalized = normalize_domain(domain)
+          return if sources.any? { |s| normalize_domain(s[:domain]) == normalized }
+
+          sources << { domain: normalized, type: 'user', description: description }
+          write_user_sources(sources)
+        end
+
+        # Removes a user-trusted domain.
+        #
+        # @param domain [String] domain to remove
+        # @return [Boolean] true if removed
+        def remove_trust(domain) # rubocop:disable Naming/PredicateMethod -- destructive action, not a predicate
+          sources = user_sources
+          normalized = normalize_domain(domain)
+          original_size = sources.size
+          sources.reject! { |s| normalize_domain(s[:domain]) == normalized }
+
+          return false if sources.size == original_size
+
+          write_user_sources(sources)
+          true
+        end
+
+        private
+
+        def default_sources
+          return [] unless @defaults_path.exist?
+
+          data = YAML.safe_load_file(@defaults_path, permitted_classes: [Symbol])
+          (data['trust_sources'] || []).map { |s| symbolize(s) }
+        end
+
+        def user_sources
+          path = user_trust_path
+          return [] unless path.exist?
+
+          data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+          (data['trust_sources'] || []).map { |s| symbolize(s) }
+        end
+
+        def write_user_sources(sources)
+          FileUtils.mkdir_p(@config_dir)
+          data = { 'trust_sources' => sources.map { |s| stringify(s) } }
+          File.write(user_trust_path, YAML.dump(data))
+        end
+
+        def user_trust_path
+          @config_dir.join(USER_TRUST_FILE)
+        end
+
+        def extract_domain(uri)
+          parsed = URI.parse(uri.to_s)
+          parsed.host || uri.to_s.split('/').first
+        rescue URI::InvalidURIError
+          uri.to_s.split('/').first
+        end
+
+        def find_source(domain)
+          normalized = normalize_domain(domain)
+          list.find { |source| normalize_domain(source[:domain]) == normalized }
+        end
+
+        def normalize_domain(domain)
+          domain.to_s.downcase.strip
+        end
+
+        def symbolize(hash)
+          hash.transform_keys(&:to_sym)
+        end
+
+        def stringify(hash)
+          hash.transform_keys(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/tools/adopt_tool.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: run rai adopt analysis.
+      #
+      # Performs local-only structural analysis of rai configuration.
+      # Read-only operation — does not modify any files.
+      #
+      # @author hugo
+      # @author claude
+      class AdoptTool
+        TOOL_NAME = 'rai_adopt'
+        DESCRIPTION = 'Run rai adopt analysis (local structural checks)'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            elaborate: {
+              type: 'boolean',
+              description: 'Show detailed findings (default: false)'
+            },
+            verbose: {
+              type: 'boolean',
+              description: 'Show processing details (default: false)'
+            }
+          }
+        }.freeze
+
+        # Executes the adopt analysis.
+        #
+        # @param elaborate [Boolean] show detailed findings
+        # @param verbose [Boolean] show processing details
+        # @return [Hash] analysis results
+        def call(elaborate: false, verbose: false)
+          results = run_analysis
+          build_response(results['findings'] || [], elaborate: elaborate, verbose: verbose)
+        rescue StandardError => e
+          ResponseHelper.error("Adopt analysis failed: #{e.message}")
+        end
+
+        private
+
+        def build_response(issues, elaborate:, verbose:)
+          { status: issues.empty? ? 'clean' : 'findings',
+            issues: elaborate ? issues : issues.first(5),
+            total_issues: issues.size, verbose: verbose, elaborate: elaborate }
+        end
+
+        def run_analysis
+          collector = RosettAi::Adopter::LocalAnalysisCollector.new
+          dir = RosettAi.root.join('conf', 'behaviour')
+          files = dir.directory? ? dir.glob('*.yml').map(&:to_s) : []
+          collector.analyze(files)
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/tools/backup_tool.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: create rai backup.
+      #
+      # Backs up global and/or local rai configuration.
+      # Write operation — creates backup archive.
+      #
+      # @author hugo
+      # @author claude
+      class BackupTool
+        TOOL_NAME = 'rai_backup'
+        DESCRIPTION = 'Create rai configuration backup'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => false,
+          'idempotentHint' => false,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            global: {
+              type: 'boolean',
+              description: 'Back up global ~/.claude/ structure (default: false)'
+            },
+            local: {
+              type: 'boolean',
+              description: 'Back up project .claude/ and CLAUDE.md (default: false)'
+            },
+            compression: {
+              type: 'string',
+              enum: ['zip', 'none'],
+              description: 'Compression format (default: zip)'
+            }
+          }
+        }.freeze
+
+        # Executes the backup.
+        #
+        # @param global [Boolean] back up global structure
+        # @param local [Boolean] back up local structure
+        # @param compression [String] compression format
+        # @return [Hash] backup results
+        def call(global: false, local: false, compression: 'zip')
+          return ResponseHelper.error('At least one scope required: global or local') unless global || local
+
+          manager = RosettAi::Backup::Manager.new
+          result = manager.create(global: global, local: local, compression: compression)
+          ResponseHelper.success('Backup created', path: result[:path], size: result[:size])
+        rescue StandardError => e
+          ResponseHelper.error("Backup failed: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/tools/behaviour_display_tool.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: display behaviour configuration table.
+      #
+      # Returns a formatted overview of all behaviours with their
+      # rules, versions, and enabled status.
+      #
+      # @author hugo
+      # @author claude
+      class BehaviourDisplayTool
+        TOOL_NAME = 'rai_behaviour_display'
+        DESCRIPTION = 'Display behaviour configuration overview'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            format: {
+              type: 'string',
+              enum: ['json', 'table'],
+              description: 'Output format (default: json)'
+            }
+          }
+        }.freeze
+
+        # Executes the display operation.
+        #
+        # @param format [String] output format ('table' or 'json')
+        # @return [Hash] formatted behaviour display
+        def call(format: 'json')
+          dir = RosettAi.root.join('conf', 'behaviour')
+          return { behaviours: [], format: format } unless dir.directory?
+
+          behaviours = dir.glob('*.yml').filter_map { |path| load_display(path) }
+          { behaviours: behaviours, format: format, total: behaviours.size }
+        end
+
+        private
+
+        def load_display(path)
+          data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+          return nil unless data.is_a?(Hash)
+
+          rules = Array(data['rules'])
+          {
+            name: data['name'],
+            version: data['version'],
+            description: data['description'],
+            rules_count: rules.size,
+            enabled_rules: rules.count { |r| r['enabled'] != false },
+            sensitive: data['sensitive'] || false,
+            file: path.basename.to_s
+          }
+        rescue Psych::SyntaxError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/tools/behaviour_list_tool.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: list rai behaviour files.
+      #
+      # Returns a structured list of all behaviour files with
+      # metadata (name, version, rule count, enabled status).
+      #
+      # @author hugo
+      # @author claude
+      class BehaviourListTool
+        TOOL_NAME = 'rai_behaviour_list'
+        DESCRIPTION = 'List all rai behaviour configuration files'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        # Executes the listing.
+        #
+        # @return [Hash] result with :behaviours array
+        def call
+          dir = RosettAi.root.join('conf', 'behaviour')
+          return { behaviours: [] } unless dir.directory?
+
+          behaviours = dir.glob('*.yml').filter_map { |path| load_behaviour(path) }
+          { behaviours: behaviours }
+        end
+
+        private
+
+        def load_behaviour(path)
+          data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+          return nil unless data.is_a?(Hash)
+
+          {
+            name: data['name'],
+            version: data['version'],
+            rules: Array(data['rules']).size,
+            file: path.basename.to_s
+          }
+        rescue Psych::SyntaxError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/tools/behaviour_manage_tool.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: manage behaviour files.
+      #
+      # Add, modify, or delete behaviour configurations.
+      # Write operation — destructive when action is 'delete'.
+      #
+      # @author hugo
+      # @author claude
+      class BehaviourManageTool
+        TOOL_NAME = 'rai_behaviour_manage'
+        DESCRIPTION = 'Add, modify, or delete rai behaviour files'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => true,
+          'idempotentHint' => false,
+          'openWorldHint' => false
+        }.freeze
+
+        VALID_ACTIONS = ['add', 'modify', 'delete'].freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['add', 'modify', 'delete'],
+              description: 'Management action to perform'
+            },
+            name: {
+              type: 'string',
+              description: 'Behaviour name'
+            },
+            description: {
+              type: 'string',
+              description: 'Behaviour description (for add/modify)'
+            },
+            force: {
+              type: 'boolean',
+              description: 'Skip confirmation for delete (default: false)'
+            }
+          },
+          required: ['action', 'name']
+        }.freeze
+
+        # Executes the behaviour management operation.
+        #
+        # @param action [String] one of 'add', 'modify', 'delete'
+        # @param name [String] behaviour name
+        # @param description [String, nil] behaviour description (for add/modify)
+        # @param force [Boolean] skip confirmation for delete
+        # @return [Hash] operation result
+        def call(action:, name:, description: nil, force: false)
+          return ResponseHelper.error("Invalid action: #{action}") unless VALID_ACTIONS.include?(action)
+          return ResponseHelper.error('Name is required') if name.nil? || name.empty?
+
+          case action
+          when 'add' then action_add(name, description: description)
+          when 'modify' then action_modify(name, description: description)
+          when 'delete' then action_delete(name, force: force)
+          end
+        rescue StandardError => e
+          ResponseHelper.error("Behaviour #{action} failed: #{e.message}")
+        end
+
+        private
+
+        def action_add(name, description:, **)
+          manager = RosettAi::Behaviour::Manager.new
+          path = manager.add(name, description: description)
+          build_manage_response("Behaviour '#{name}' created", path)
+        end
+
+        def action_modify(name, description:, **)
+          manager = RosettAi::Behaviour::Manager.new
+          path = manager.modify(name, description: description)
+          build_manage_response("Behaviour '#{name}' modified", path)
+        end
+
+        def action_delete(name, force:, **)
+          manager = RosettAi::Behaviour::Manager.new
+          manager.delete(name, options: { force_delete: force })
+          ResponseHelper.success("Behaviour '#{name}' deleted")
+        end
+
+        # Builds a response that includes enforcement validation status.
+        #
+        # @param message [String]
+        # @param path [Pathname, nil]
+        # @return [Hash]
+        def build_manage_response(message, path)
+          response = ResponseHelper.success(message)
+          return response unless path.is_a?(Pathname) && path.exist?
+
+          data = RosettAi::YamlLoader.load_file(path.to_s)
+          enforcement = RosettAi::Mcp::Enforcement::Validator.new.validate(data)
+          response[:enforcement] = {
+            enforceable: enforcement[:valid].count { |r| r[:type] == 'enforceable' },
+            downgraded: enforcement[:downgraded].size,
+            warnings: enforcement[:downgraded].flat_map { |d| d[:warnings] }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/tools/behaviour_show_tool.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: show a specific behaviour file.
+      #
+      # Returns the full content and metadata of a named behaviour.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class BehaviourShowTool
+        TOOL_NAME = 'rai_behaviour_show'
+        DESCRIPTION = 'Show details of a specific rai behaviour'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+              description: 'Behaviour name to display'
+            }
+          },
+          required: ['name']
+        }.freeze
+
+        # Executes the show operation.
+        #
+        # @param name [String] behaviour name (without .yml)
+        # @return [Hash] behaviour data or error
+        def call(name:)
+          path = RosettAi.root.join('conf', 'behaviour', "#{name}.yml")
+          return ResponseHelper.error("Behaviour not found: #{name}") unless path.exist?
+
+          data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+          {
+            name: data['name'],
+            description: data['description'],
+            version: data['version'],
+            author: data['author'],
+            rules: Array(data['rules']),
+            sensitive: data['sensitive'] || false,
+            file: path.basename.to_s
+          }
+        rescue Psych::SyntaxError => e
+          ResponseHelper.error("YAML parse error in #{name}: #{e.message}")
+        end
+      end
+    end
+  end
+end