rosett-ai 1.3.3

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

@@ -0,0 +1,173 @@
+# 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: preview a generated enforcement hook script.
+      #
+      # Generates a Ruby hook script from behaviour rules without writing
+      # anything to disk. Allows inspection before installing via
+      # {HookInstallTool}. Strictly read-only.
+      #
+      # Delegates generation to {Enforcement::HookGenerator} and validation
+      # to {Enforcement::Validator}.
+      #
+      # @author hugo
+      # @author claude
+      class HookPreviewTool
+        TOOL_NAME = 'rai_hook_preview'
+        DESCRIPTION = 'Preview generated enforcement hook script (read-only, no side effects)'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            behaviour_name: {
+              type: 'string',
+              description: 'Behaviour to preview hook for (default: all enforceable)'
+            },
+            rule_id: {
+              type: 'string',
+              description: 'Specific rule ID to preview hook for'
+            },
+            scope: {
+              type: 'string',
+              description: 'Preview scope context'
+            }
+          }
+        }.freeze
+
+        # Generates a preview of the enforcement hook script.
+        #
+        # @param behaviour_name [String, nil] specific behaviour to generate for
+        # @param rule_id [String, nil] specific rule within the behaviour
+        # @param scope [String, nil] scope filter ('global', 'project')
+        # @return [Hash] generated script content and metadata
+        def call(behaviour_name: nil, rule_id: nil, scope: nil)
+          behaviours = load_behaviours(behaviour_name, scope)
+          validated = validate_and_collect(behaviours, rule_id)
+
+          return ResponseHelper.error('No enforceable rules found') if validated[:rules].empty?
+
+          script = generate_script(validated)
+          build_response(script, validated, scope)
+        rescue StandardError => e
+          ResponseHelper.error("Hook preview failed: #{e.message}")
+        end
+
+        private
+
+        # Loads behaviour files from the appropriate directories.
+        #
+        # @param behaviour_name [String, nil]
+        # @param scope [String, nil]
+        # @return [Array<Hash>] loaded behaviour data with metadata
+        def load_behaviours(behaviour_name, scope)
+          results = []
+          each_behaviour_file(scope) do |_path, data|
+            next if behaviour_name && data['name'] != behaviour_name
+
+            results << data
+          end
+          results
+        end
+
+        # Validates behaviours and collects enforceable rules.
+        #
+        # @param behaviours [Array<Hash>]
+        # @param rule_id [String, nil]
+        # @return [Hash] :rules, :downgraded, :behaviour_name, :behaviour_version
+        def validate_and_collect(behaviours, rule_id)
+          validator = Enforcement::Validator.new
+          all_rules = []
+          all_downgraded = []
+          names = []
+
+          behaviours.each do |data|
+            result = validator.validate(data)
+            rules = result[:valid].select { |r| r[:type] == 'enforceable' }
+            rules = rules.select { |r| r[:rule_id] == rule_id } if rule_id
+            all_rules.concat(rules)
+            all_downgraded.concat(result[:downgraded])
+            names << data['name']
+          end
+
+          { rules: all_rules, downgraded: all_downgraded,
+            behaviour_name: names.join(', '),
+            behaviour_version: behaviours.first&.fetch('version', '0.0.0') || '0.0.0' }
+        end
+
+        # Generates the hook script via HookGenerator.
+        #
+        # @param validated [Hash]
+        # @return [String]
+        def generate_script(validated)
+          generator = Enforcement::HookGenerator.new
+          generator.generate(
+            validated[:rules],
+            behaviour_name: validated[:behaviour_name],
+            behaviour_version: validated[:behaviour_version]
+          )
+        end
+
+        # @param script [String]
+        # @param validated [Hash]
+        # @param scope [String, nil]
+        # @return [Hash]
+        def build_response(script, validated, scope)
+          response = {
+            script: script,
+            rules_count: validated[:rules].size,
+            behaviours: validated[:rules].map { |r| r[:behaviour] }.uniq,
+            scope: scope || 'global',
+            preview_only: true
+          }
+          response[:downgraded] = validated[:downgraded] unless validated[:downgraded].empty?
+          response
+        end
+
+        # @param scope [String, nil]
+        # @yield [Pathname, Hash]
+        def each_behaviour_file(scope)
+          dirs = behaviour_dirs(scope)
+          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)
+            rescue Psych::Exception
+              next
+            end
+          end
+        end
+
+        # @param scope [String, nil]
+        # @return [Array<Pathname>]
+        def behaviour_dirs(scope)
+          case scope
+          when 'project'
+            [RosettAi.conf_root.join('conf', 'behaviour')]
+          else
+            dirs = [RosettAi.root.join('conf', 'behaviour')]
+            xdg = RosettAi.paths.rai_conf_dir.join('behaviour')
+            dirs << xdg if xdg.directory?
+            dirs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# 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 git hooks status.
+      #
+      # Lists configured hooks and their installation status.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class HooksStatusTool
+        TOOL_NAME = 'rai_hooks_status'
+        DESCRIPTION = 'Show git hooks list and installation status'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        VALID_ACTIONS = ['list', 'status'].freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['list', 'status'],
+              description: 'Hooks action (default: status)'
+            }
+          }
+        }.freeze
+
+        # Known overcommit hook phases.
+        HOOK_PHASES = [
+          'PreCommit', 'CommitMsg', 'PrePush', 'PreRebase',
+          'PostCheckout', 'PostCommit', 'PostMerge', 'PostRewrite'
+        ].freeze
+
+        # Executes the hooks query.
+        #
+        # @param action [String] one of 'list' or 'status'
+        # @return [Hash] hooks information
+        def call(action: 'status')
+          return ResponseHelper.error("Invalid action: #{action}") unless VALID_ACTIONS.include?(action)
+
+          hooks_config = RosettAi.root.join('.overcommit.yml')
+          return ResponseHelper.error('No .overcommit.yml found') unless hooks_config.exist?
+
+          data = YAML.safe_load_file(hooks_config, permitted_classes: [Symbol])
+          {
+            action: action,
+            installed: RosettAi.root.join('.git', 'hooks', 'overcommit-hook').exist?,
+            hooks: extract_hooks(data)
+          }
+        rescue Psych::SyntaxError => e
+          ResponseHelper.error("Hooks config parse error: #{e.message}")
+        end
+
+        private
+
+        # Extracts hook configuration for all overcommit phases.
+        #
+        # @param data [Hash] parsed .overcommit.yml content
+        # @return [Hash{String => Array<String>}] phase to hook names
+        def extract_hooks(data)
+          return {} unless data.is_a?(Hash)
+
+          data.each_with_object({}) do |(phase, hooks), result|
+            next unless hooks.is_a?(Hash) && HOOK_PHASES.include?(phase)
+
+            result[phase] = hooks.keys.reject { |k| k == 'ALL' }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# 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: initialize rosett-ai structure.
+      #
+      # Sets up global, local, or project directory structure.
+      # Write operation — creates directories and files.
+      #
+      # @author hugo
+      # @author claude
+      class InitTool
+        TOOL_NAME = 'rai_init'
+        DESCRIPTION = 'Initialize rosett-ai directory structure (global, local, or project)'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            global: {
+              type: 'boolean',
+              description: 'Initialize global ~/.claude/ structure (default: false)'
+            },
+            local: {
+              type: 'boolean',
+              description: 'Initialize project-local .claude/ structure (default: false)'
+            },
+            project: {
+              type: 'boolean',
+              description: 'Initialize .rosett-ai/ project structure (default: false)'
+            }
+          }
+        }.freeze
+
+        # Executes the initialization.
+        #
+        # @param global [Boolean] set up global structure
+        # @param local [Boolean] set up project-local structure
+        # @param project [Boolean] set up .rosett-ai/ project structure
+        # @return [Hash] initialization results
+        def call(global: false, local: false, project: false)
+          unless global || local || project
+            return ResponseHelper.error('At least one scope required: global, local, or project')
+          end
+
+          results = { scopes: [], created: [] }
+          init_global(results) if global
+          init_local(results) if local
+          init_project(results) if project
+          ResponseHelper.success('Initialization complete', results)
+        rescue StandardError => e
+          ResponseHelper.error("Init failed: #{e.message}")
+        end
+
+        private
+
+        def init_global(results)
+          initializer = RosettAi::Init::GlobalInitializer.new
+          initializer.setup
+          results[:scopes] << 'global'
+        end
+
+        def init_local(results)
+          initializer = RosettAi::Init::LocalInitializer.new
+          initializer.setup
+          results[:scopes] << 'local'
+        end
+
+        def init_project(results)
+          initializer = RosettAi::Init::ProjectInitializer.new
+          initializer.setup
+          results[:scopes] << 'project'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# 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 license status.
+      #
+      # Returns the current license activation status.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class LicenseStatusTool
+        TOOL_NAME = 'rai_license_status'
+        DESCRIPTION = 'Show rai license activation status'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        # Executes the license status check.
+        #
+        # @return [Hash] license status information
+        def call
+          result = RosettAi::Licensing::LicenseValidator.new.validate
+          {
+            active: result[:valid],
+            tier: result[:tier]&.to_s,
+            key_present: result[:key_present],
+            message: result[:message]
+          }
+        rescue StandardError => e
+          ResponseHelper.error("License check failed: #{e.message}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# 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 project status and information.
+      #
+      # Returns project lifecycle status, info, or drift detection.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class ProjectTool
+        TOOL_NAME = 'rai_project'
+        DESCRIPTION = 'Show rai project status, info, or drift detection'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        VALID_ACTIONS = ['status', 'info', 'drift'].freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['status', 'info', 'drift'],
+              description: 'Project action (default: status)'
+            }
+          }
+        }.freeze
+
+        # Executes the project query.
+        #
+        # @param action [String] one of 'status', 'info', 'drift'
+        # @return [Hash] project information
+        def call(action: 'status')
+          return ResponseHelper.error("Invalid action: #{action}") unless VALID_ACTIONS.include?(action)
+
+          case action
+          when 'status' then action_status
+          when 'info' then action_info
+          when 'drift' then action_drift
+          end
+        rescue StandardError => e
+          ResponseHelper.error("Project #{action} failed: #{e.message}")
+        end
+
+        private
+
+        def action_status
+          {
+            project_root: RosettAi.root.to_s,
+            version: RosettAi::VERSION,
+            behaviours: count_files('conf/behaviour'),
+            designs: count_files('conf/design'),
+            engines: detect_engines
+          }
+        end
+
+        def action_info
+          spec = load_gemspec
+          {
+            name: spec&.name || 'rosett-ai',
+            summary: spec&.summary || 'Unknown',
+            version: RosettAi::VERSION,
+            license: spec&.license || 'Unknown',
+            authors: spec&.authors || [],
+            homepage: spec&.homepage || 'Unknown',
+            ruby_version: RUBY_VERSION,
+            required_ruby: spec&.required_ruby_version&.to_s || 'Unknown',
+            project_root: RosettAi.root.to_s
+          }
+        end
+
+        def action_drift
+          compiled_dir = Pathname.new(File.expand_path('~/.claude/rules'))
+          {
+            compiled_rules_exist: compiled_dir.directory?,
+            compiled_count: compiled_dir.directory? ? compiled_dir.glob('*.md').size : 0,
+            source_count: count_files('conf/behaviour') + count_files('conf/design')
+          }
+        end
+
+        def count_files(subdir)
+          dir = RosettAi.root.join(subdir)
+          dir.directory? ? dir.glob('*.yml').size : 0
+        end
+
+        def detect_engines
+          RosettAi::Plugins::Registry.available(:engine).size
+        rescue StandardError
+          0
+        end
+
+        # Loads the gemspec from the project root.
+        #
+        # @return [Gem::Specification, nil]
+        def load_gemspec
+          gemspec = RosettAi.root.glob('*.gemspec').first
+          return nil unless gemspec&.exist?
+
+          Gem::Specification.load(gemspec.to_s)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# 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 AI provenance information.
+      #
+      # Validates, shows, and logs provenance entries.
+      # Read-only operation.
+      #
+      # @author hugo
+      # @author claude
+      class ProvenanceTool
+        TOOL_NAME = 'rai_provenance'
+        DESCRIPTION = 'Query AI provenance (validate, show, log)'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        VALID_ACTIONS = ['validate', 'show', 'log'].freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['validate', 'show', 'log'],
+              description: 'Provenance action (default: log)'
+            },
+            commit: {
+              type: 'string',
+              description: 'Commit SHA to show provenance for (for show action)'
+            },
+            file: {
+              type: 'string',
+              description: 'File path to show provenance for (for show action)'
+            },
+            role: {
+              type: 'string',
+              description: 'Filter by AI role (for log action)'
+            }
+          }
+        }.freeze
+
+        # Executes the provenance query.
+        #
+        # @param action [String] one of 'validate', 'show', 'log'
+        # @param commit [String, nil] commit SHA for show action
+        # @param file [String, nil] file path filter
+        # @param role [String, nil] AI role filter for log
+        # @return [Hash] provenance information
+        def call(action: 'log', commit: nil, file: nil, role: nil)
+          return ResponseHelper.error("Invalid action: #{action}") unless VALID_ACTIONS.include?(action)
+
+          tracker = RosettAi::Provenance::Tracker.new
+          case action
+          when 'validate' then action_validate(tracker)
+          when 'show' then action_show(tracker, commit: commit, file: file)
+          when 'log' then action_log(tracker, role: role)
+          end
+        rescue StandardError => e
+          ResponseHelper.error("Provenance #{action} failed: #{e.message}")
+        end
+
+        private
+
+        def action_validate(tracker)
+          results = tracker.validate
+          { valid: results[:errors].empty?, errors: results[:errors] }
+        end
+
+        def action_show(tracker, commit:, file:)
+          entries = if commit
+                      [tracker.find_by_commit(commit)].compact
+                    elsif file
+                      tracker.find_by_file(file)
+                    else
+                      return ResponseHelper.error('Either commit or file is required for show')
+                    end
+          { entries: entries }
+        end
+
+        def action_log(tracker, role:)
+          entries = tracker.log(role: role)
+          { entries: entries, total: entries.size }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# 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: initialize provenance tracking.
+      #
+      # Creates .ai-provenance.yml in the project root.
+      # Write operation — creates a new file.
+      #
+      # @author hugo
+      # @author claude
+      class ProvenanceWriteTool
+        TOOL_NAME = 'rai_provenance_init'
+        DESCRIPTION = 'Initialize AI provenance tracking in a project'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        # Executes the provenance initialization.
+        #
+        # @return [Hash] initialization result
+        def call
+          store = RosettAi::Provenance::Store.new(root: Dir.pwd)
+          store.init
+          ResponseHelper.success('Provenance tracking initialized', path: store.path.to_s)
+        rescue StandardError => e
+          ResponseHelper.error("Provenance init failed: #{e.message}")
+        end
+      end
+    end
+  end
+end