rosett-ai 1.3.3

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

@@ -0,0 +1,81 @@
+# 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: retrofit native configurations.
+      #
+      # Scan and convert native AI tool configs to Rosett-AI YAML.
+      # Write operation for convert action.
+      #
+      # @author hugo
+      # @author claude
+      class RetrofitTool
+        TOOL_NAME = 'rai_retrofit'
+        DESCRIPTION = 'Scan and convert native AI configs to rosett-ai format'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        VALID_ACTIONS = ['engines', 'scan', 'convert'].freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['engines', 'scan', 'convert'],
+              description: 'Retrofit action (default: scan)'
+            },
+            engine: {
+              type: 'string',
+              description: 'Engine to retrofit from'
+            },
+            simulate: {
+              type: 'boolean',
+              description: 'Dry-run mode (default: true)'
+            }
+          }
+        }.freeze
+
+        # Executes the retrofit operation.
+        #
+        # @param action [String] one of 'engines', 'scan', 'convert'
+        # @param engine [String, nil] specific engine for conversion
+        # @param simulate [Boolean] dry-run mode for convert
+        # @return [Hash] retrofit results
+        def call(action: 'scan', engine: nil, simulate: true)
+          return ResponseHelper.error("Invalid action: #{action}") unless VALID_ACTIONS.include?(action)
+
+          retrofitter = RosettAi::Retrofit::Scanner.new
+          case action
+          when 'engines' then { parsers: retrofitter.available_parsers }
+          when 'scan' then { findings: retrofitter.scan }
+          when 'convert' then action_convert(retrofitter, engine, simulate)
+          end
+        rescue StandardError => e
+          ResponseHelper.error("Retrofit #{action} failed: #{e.message}")
+        end
+
+        private
+
+        def action_convert(retrofitter, engine, simulate)
+          result = retrofitter.convert(engine: engine, options: { dry_run: simulate })
+          {
+            simulate: simulate,
+            engine: engine,
+            converted: result[:converted],
+            files: result[:files]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'yaml'
+require 'pathname'
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: search compiled rules by keyword.
+      #
+      # Searches behaviour YAML source files for rules matching a keyword,
+      # with optional filters for minimum priority, scope, and enabled status.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class RuleSearchTool
+        TOOL_NAME = 'rai_rule_search'
+        DESCRIPTION = 'Search rules by keyword with optional priority/scope/enabled filters'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            keyword: {
+              type: 'string',
+              description: 'Search keyword to match against rule descriptions and IDs'
+            },
+            priority_min: {
+              type: 'integer',
+              minimum: 0,
+              maximum: 100,
+              description: 'Minimum priority threshold (0-100)'
+            },
+            scope: {
+              type: 'string',
+              description: 'Behaviour scope to search within'
+            },
+            enabled_only: {
+              type: 'boolean',
+              description: 'Only return enabled rules (default: true)'
+            }
+          },
+          required: ['keyword']
+        }.freeze
+
+        # Searches rules across all behaviour files.
+        #
+        # @param keyword [String] search term (matched case-insensitively)
+        # @param priority_min [Integer, nil] minimum priority filter
+        # @param scope [String, nil] scope filter ('global', 'project', 'personal')
+        # @param enabled_only [Boolean] filter to enabled rules only (default true)
+        # @return [Hash] matching rules with metadata
+        def call(keyword:, priority_min: nil, scope: nil, enabled_only: true)
+          matches = []
+          each_behaviour_file do |path, data|
+            search_behaviour(data, keyword, path, matches)
+          end
+
+          matches = apply_filters(matches, priority_min, scope, enabled_only)
+          matches.sort_by! { |m| -(m[:priority] || 0) }
+
+          { keyword: keyword, matches: matches, total: matches.size }
+        rescue StandardError => e
+          ResponseHelper.error("Rule search failed: #{e.message}")
+        end
+
+        private
+
+        # @yield [Pathname, Hash] path and parsed YAML data
+        def each_behaviour_file
+          behaviour_dirs.each do |dir|
+            next unless dir.directory?
+
+            dir.glob('*.yml').each do |path|
+              data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+              yield path, data if data.is_a?(Hash)
+            end
+          end
+        end
+
+        # @return [Array<Pathname>] directories to search for behaviours
+        def behaviour_dirs
+          dirs = [RosettAi.root.join('conf', 'behaviour')]
+          xdg = RosettAi.paths.rai_conf_dir.join('behaviour')
+          dirs << xdg if xdg.directory?
+          dirs
+        end
+
+        # @param data [Hash] parsed behaviour YAML
+        # @param keyword [String] search term
+        # @param path [Pathname] source file path
+        # @param matches [Array<Hash>] accumulator
+        def search_behaviour(data, keyword, path, matches)
+          rules = data['rules']
+          return unless rules.is_a?(Array)
+
+          pattern = Regexp.new(Regexp.escape(keyword), Regexp::IGNORECASE)
+          behaviour_name = data['name'] || File.basename(path, '.yml')
+
+          rules.each do |rule|
+            next unless rule.is_a?(Hash)
+
+            description = rule['description'].to_s
+            next unless description.match?(pattern)
+
+            matches << build_match(behaviour_name, rule, description, data, pattern)
+          end
+        end
+
+        # @param behaviour_name [String]
+        # @param rule [Hash]
+        # @param description [String]
+        # @param data [Hash]
+        # @param pattern [Regexp]
+        # @return [Hash]
+        def build_match(behaviour_name, rule, description, data, pattern)
+          snippet = extract_snippet(description, pattern)
+          {
+            behaviour: behaviour_name,
+            rule_id: rule['id'],
+            priority: rule['priority'] || 0,
+            enabled: rule.fetch('enabled', true),
+            scope: data['scope'],
+            snippet: snippet
+          }
+        end
+
+        # @param text [String]
+        # @param pattern [Regexp]
+        # @return [String] snippet around the first match (max 120 chars)
+        def extract_snippet(text, pattern)
+          match = pattern.match(text)
+          return text[0, 120] unless match
+
+          start = [match.begin(0) - 40, 0].max
+          text[start, 120].strip
+        end
+
+        # @param matches [Array<Hash>]
+        # @param priority_min [Integer, nil]
+        # @param scope [String, nil]
+        # @param enabled_only [Boolean]
+        # @return [Array<Hash>]
+        def apply_filters(matches, priority_min, scope, enabled_only)
+          matches = matches.select { |m| m[:priority] >= priority_min } if priority_min
+          matches = matches.select { |m| m[:scope] == scope } if scope
+          matches = matches.select { |m| m[:enabled] } if enabled_only
+          matches
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'json'
+require 'pathname'
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: retrieve JSON Schema content for validation.
+      #
+      # Returns the raw JSON Schema used for validating behaviour,
+      # design, or tooling configuration files. Read-only.
+      #
+      # @author hugo
+      # @author claude
+      class SchemaGetTool
+        TOOL_NAME = 'rai_schema_get'
+        DESCRIPTION = 'Get JSON Schema content for behaviour/design/tooling validation'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        VALID_SCHEMAS = {
+          'behaviour' => 'behaviour_schema.json',
+          'design' => 'design_schema.json',
+          'tooling' => 'tooling_schema.json',
+          'workflow' => 'workflow_schema.json',
+          'provenance' => 'provenance_schema.json',
+          'policy' => 'policy_schema.json'
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            schema_name: {
+              type: 'string',
+              enum: ['behaviour', 'design', 'tooling', 'workflow', 'provenance', 'policy'],
+              description: 'Schema name to retrieve'
+            }
+          },
+          required: ['schema_name']
+        }.freeze
+
+        # Retrieves the JSON Schema content.
+        #
+        # @param schema_name [String] one of: behaviour, design, tooling, workflow, provenance, policy
+        # @return [Hash] schema content and metadata
+        def call(schema_name:)
+          filename = VALID_SCHEMAS[schema_name]
+          return invalid_schema_response(schema_name) unless filename
+
+          schema_path = RosettAi.root.join('conf', 'schemas', filename)
+          return missing_schema_response(schema_path) unless schema_path.exist?
+
+          content = JSON.parse(schema_path.read)
+          {
+            schema_name: schema_name,
+            filename: filename,
+            content: content,
+            path: schema_path.to_s
+          }
+        rescue JSON::ParserError => e
+          ResponseHelper.error("Schema parse error: #{e.message}")
+        rescue StandardError => e
+          ResponseHelper.error("Schema get failed: #{e.message}")
+        end
+
+        private
+
+        # @param schema_name [String]
+        # @return [Hash]
+        def invalid_schema_response(schema_name)
+          ResponseHelper.error(
+            "Unknown schema: #{schema_name}. " \
+            "Available: #{VALID_SCHEMAS.keys.join(', ')}"
+          )
+        end
+
+        # @param schema_path [Pathname]
+        # @return [Hash]
+        def missing_schema_response(schema_path)
+          ResponseHelper.error("Schema file not found: #{schema_path}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# 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 tooling validation.
+      #
+      # Validates CI YAML syntax and checks tool versions.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class ToolingTool
+        TOOL_NAME = 'rai_tooling'
+        DESCRIPTION = 'Run tooling validation (CI YAML, version checks)'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        VALID_ACTIONS = ['validate-ci-yaml', 'check-versions'].freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['validate-ci-yaml', 'check-versions'],
+              description: 'Tooling action (default: validate-ci-yaml)'
+            },
+            verbose: {
+              type: 'boolean',
+              description: 'Show detailed output (default: false)'
+            }
+          }
+        }.freeze
+
+        # Executes tooling validation.
+        #
+        # @param action [String] one of 'validate-ci-yaml', 'check-versions'
+        # @param verbose [Boolean] show detailed output
+        # @return [Hash] validation results
+        def call(action: 'validate-ci-yaml', verbose: false)
+          return ResponseHelper.error("Invalid action: #{action}") unless VALID_ACTIONS.include?(action)
+
+          case action
+          when 'validate-ci-yaml' then validate_ci_yaml(verbose)
+          when 'check-versions' then check_versions(verbose)
+          end
+        rescue StandardError => e
+          ResponseHelper.error("Tooling #{action} failed: #{e.message}")
+        end
+
+        private
+
+        def validate_ci_yaml(verbose)
+          validator = RosettAi::Tooling::CiYamlValidator.new
+          results = validator.validate
+          {
+            valid: results[:errors].empty?,
+            files_checked: results[:files],
+            errors: results[:errors],
+            verbose: verbose
+          }
+        end
+
+        def check_versions(verbose)
+          checker = RosettAi::Tooling::VersionChecker.new
+          results = checker.check
+          {
+            up_to_date: results[:outdated].empty?,
+            tools: results[:tools],
+            outdated: results[:outdated],
+            verbose: verbose
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'yaml'
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: validate rai configuration files.
+      #
+      # Performs both YAML syntax and JSON Schema validation using the
+      # project's {RosettAi::Validators::SchemaValidator} hierarchy.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class ValidateTool
+        TOOL_NAME = 'rai_validate'
+        DESCRIPTION = 'Validate rai configuration files (behaviours, designs, tooling)'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            scope: {
+              type: 'string',
+              enum: ['behaviour', 'design', 'tooling'],
+              description: 'Validation scope (default: all scopes)'
+            }
+          }
+        }.freeze
+
+        # Maps scope names to their validator classes.
+        SCOPE_VALIDATORS = {
+          'behaviour' => -> { RosettAi::Validators::BehaviourValidator.new },
+          'design' => -> { RosettAi::Validators::DesignValidator.new },
+          'tooling' => -> { RosettAi::Validators::ToolingValidator.new }
+        }.freeze
+
+        # Executes the validation with JSON Schema checking.
+        #
+        # @param scope [String, nil] optional scope filter ('behaviour', 'design', 'tooling')
+        # @return [Hash] result with :valid, :errors, :warnings
+        def call(scope: nil)
+          results = { valid: true, errors: [], warnings: [] }
+          scopes = scope ? [scope] : ['behaviour', 'design']
+
+          scopes.each { |s| validate_scope(s, results) }
+          results[:valid] = results[:errors].empty?
+          results
+        end
+
+        private
+
+        # @param scope [String]
+        # @param results [Hash]
+        # @return [void]
+        def validate_scope(scope, results)
+          dir = RosettAi.root.join('conf', scope)
+          return unless dir.directory?
+
+          validator = build_validator(scope)
+          dir.glob('*.yml').each do |path|
+            validate_file(path, scope, validator, results)
+          end
+        end
+
+        # @param scope [String]
+        # @return [RosettAi::Validators::SchemaValidator, nil]
+        def build_validator(scope)
+          factory = SCOPE_VALIDATORS[scope]
+          factory&.call
+        rescue RosettAi::ConfigurationError
+          nil
+        end
+
+        # @param path [Pathname]
+        # @param scope [String]
+        # @param validator [RosettAi::Validators::SchemaValidator, nil]
+        # @param results [Hash]
+        # @return [void]
+        def validate_file(path, scope, validator, results)
+          file_str = path.to_s
+          YAML.safe_load_file(path, permitted_classes: [Symbol])
+
+          return unless validator
+
+          validator.validate(file_str).each do |error|
+            results[:errors] << { file: file_str, scope: scope, message: error }
+          end
+        rescue Psych::SyntaxError => e
+          results[:errors] << { file: file_str, scope: scope, message: e.message }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# 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: execute a named workflow.
+      #
+      # Runs a declarative workflow by name.
+      # Write operation — executes workflow steps.
+      #
+      # @author hugo
+      # @author claude
+      class WorkflowExecuteTool
+        TOOL_NAME = 'rai_workflow_execute'
+        DESCRIPTION = 'Execute a named rai workflow'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => false,
+          'idempotentHint' => false,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+              description: 'Workflow name to execute'
+            },
+            resume: {
+              type: 'boolean',
+              description: 'Resume a previously interrupted workflow (default: false)'
+            }
+          },
+          required: ['name']
+        }.freeze
+
+        # Executes the named workflow.
+        #
+        # @param name [String] workflow name
+        # @param resume [Boolean] resume a previously interrupted workflow
+        # @return [Hash] execution results
+        def call(name:, resume: false)
+          return ResponseHelper.error('Workflow name is required') if name.nil? || name.empty?
+
+          path = resolve_workflow(name)
+          return ResponseHelper.error("Workflow '#{name}' not found") unless path
+
+          engine = RosettAi::Workflow::Engine.new(workflow_path: path)
+          build_result(name, engine.execute(resume: resume))
+        rescue StandardError => e
+          ResponseHelper.error("Workflow execute failed: #{e.message}")
+        end
+
+        private
+
+        def build_result(name, summary)
+          { name: name, status: summary[:status],
+            steps_completed: summary[:steps_completed], output: summary[:output] }
+        end
+
+        def resolve_workflow(name)
+          dir = RosettAi.root.join('conf', 'workflows')
+          path = dir.join("#{name}.yml")
+          path.exist? ? path : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# 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: query workflow definitions.
+      #
+      # Lists, validates, and simulates declarative workflows.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class WorkflowTool
+        TOOL_NAME = 'rai_workflow'
+        DESCRIPTION = 'List, validate, or simulate rai workflows'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        VALID_ACTIONS = ['list', 'validate', 'simulate'].freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['list', 'validate', 'simulate'],
+              description: 'Workflow action (default: list)'
+            },
+            name: {
+              type: 'string',
+              description: 'Workflow name (required for validate/simulate)'
+            }
+          }
+        }.freeze
+
+        # Executes the workflow query.
+        #
+        # @param action [String] one of 'list', 'validate', 'simulate'
+        # @param name [String, nil] workflow name (for validate/simulate)
+        # @return [Hash] workflow information
+        def call(action: 'list', name: nil)
+          return ResponseHelper.error("Invalid action: #{action}") unless VALID_ACTIONS.include?(action)
+
+          manager = RosettAi::Workflow::Manager.new
+          case action
+          when 'list' then { workflows: manager.list }
+          when 'validate' then action_validate(manager, name)
+          when 'simulate' then action_simulate(manager, name)
+          end
+        rescue StandardError => e
+          ResponseHelper.error("Workflow #{action} failed: #{e.message}")
+        end
+
+        private
+
+        def action_validate(manager, name)
+          results = name ? manager.validate(name) : manager.validate_all
+          { valid: results[:errors].empty?, errors: results[:errors] }
+        end
+
+        def action_simulate(manager, name)
+          return ResponseHelper.error('Workflow name required for simulate') unless name
+
+          result = manager.simulate(name)
+          { name: name, steps: result[:steps], estimated_duration: result[:duration] }
+        end
+      end
+    end
+  end
+end