rosett-ai 1.3.3

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'digest'
+require 'pathname'
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: show compilation staleness status.
+      #
+      # Compares source behaviour/design YAML files against their compiled
+      # output, reporting per-file checksums and staleness. Read-only.
+      #
+      # @author hugo
+      # @author claude
+      class CompileStatusTool
+        TOOL_NAME = 'rai_compile_status'
+        DESCRIPTION = 'Show compiled rules staleness — source vs compiled checksums'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            scope: {
+              type: 'string',
+              description: 'Scope to check staleness for (default: all)'
+            }
+          }
+        }.freeze
+
+        # Checks staleness of compiled output files.
+        #
+        # @param scope [String, nil] optional filter ('behaviour', 'design')
+        # @return [Hash] per-file staleness report
+        def call(scope: nil)
+          compiled_dir = RosettAi.paths.rules_dir
+          source_dir = resolve_source_dir
+
+          files = collect_source_files(source_dir, scope)
+          report = files.map { |src| build_file_report(src, compiled_dir) }
+
+          stale_count = report.count { |r| r[:stale] }
+          {
+            files: report,
+            total: report.size,
+            stale: stale_count,
+            up_to_date: report.size - stale_count,
+            compiled_dir: compiled_dir.to_s,
+            source_dir: source_dir.to_s
+          }
+        rescue StandardError => e
+          ResponseHelper.error("Compile status failed: #{e.message}")
+        end
+
+        private
+
+        # @return [Pathname]
+        def resolve_source_dir
+          return RosettAi.root.join('conf') if RosettAi.context.rai_internal?
+
+          RosettAi.paths.rai_conf_dir
+        end
+
+        # @param source_dir [Pathname]
+        # @param scope [String, nil]
+        # @return [Array<Pathname>]
+        def collect_source_files(source_dir, scope)
+          categories = scope ? [scope] : ['behaviour', 'design']
+          categories.flat_map do |cat|
+            dir = source_dir.join(cat)
+            dir.directory? ? dir.glob('*.yml').sort : []
+          end
+        end
+
+        # @param source_path [Pathname]
+        # @param compiled_dir [Pathname]
+        # @return [Hash]
+        def build_file_report(source_path, compiled_dir)
+          category = source_path.parent.basename.to_s
+          basename = source_path.basename('.yml').to_s
+          compiled_name = "#{category}-#{basename}.md"
+          compiled_path = compiled_dir.join(compiled_name)
+
+          source_checksum = file_checksum(source_path)
+          compiled_exists = compiled_path.exist?
+          compiled_checksum = compiled_exists ? file_checksum(compiled_path) : nil
+
+          {
+            source: source_path.to_s,
+            compiled: compiled_path.to_s,
+            source_checksum: source_checksum,
+            compiled_checksum: compiled_checksum,
+            compiled_exists: compiled_exists,
+            stale: !compiled_exists || source_newer?(source_path, compiled_path)
+          }
+        end
+
+        # @param path [Pathname]
+        # @return [String] SHA-256 hex digest
+        def file_checksum(path)
+          Digest::SHA256.hexdigest(path.read)
+        end
+
+        # @param source [Pathname]
+        # @param compiled [Pathname]
+        # @return [Boolean]
+        def source_newer?(source, compiled)
+          source.mtime > compiled.mtime
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'fileutils'
+require 'digest'
+
+module RosettAi
+  module Mcp
+    module Tools
+      # MCP tool: compile rai behaviours to engine-native format.
+      #
+      # Delegates to the real {RosettAi::Compiler::CompilationPipeline}.
+      # When simulate=true, returns diffs without writing files.
+      # When simulate=false, writes compiled output to disk.
+      #
+      # @author hugo
+      # @author claude
+      class CompileTool
+        TOOL_NAME = 'rai_compile'
+        DESCRIPTION = 'Compile rai behaviours to engine-native format'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            simulate: {
+              type: 'boolean',
+              description: 'Dry-run mode — show what would change without writing (default: true)'
+            },
+            engine: {
+              type: 'string',
+              description: 'Target engine format (default: claude)'
+            }
+          }
+        }.freeze
+
+        # Executes the compilation via the real pipeline.
+        #
+        # @param simulate [Boolean] dry-run mode (default true)
+        # @param engine [String] target engine (default 'claude')
+        # @return [Hash] result with compiled file details
+        def call(simulate: true, engine: 'claude')
+          backend = RosettAi::Compiler::Backend.for(engine)
+          pipeline = build_pipeline(backend)
+          compiled = pipeline.compile
+
+          if simulate
+            build_simulate_result(pipeline, compiled, engine)
+          else
+            build_write_result(pipeline, compiled, engine)
+          end
+        rescue RosettAi::Error => e
+          ResponseHelper.error("Compilation failed: #{e.message}")
+        end
+
+        private
+
+        # @param backend [RosettAi::Compiler::Backend] rendering backend
+        # @return [RosettAi::Compiler::CompilationPipeline]
+        def build_pipeline(backend)
+          scope = detect_scope
+          RosettAi::Compiler::CompilationPipeline.new(
+            source_dir: resolve_source_dir(scope),
+            target_dir: resolve_target_dir(backend, scope),
+            schema_dir: RosettAi.root.join('conf', 'schemas'),
+            backend: backend,
+            scope: scope,
+            additional_source_dirs: additional_dirs(scope)
+          )
+        end
+
+        # @return [Symbol] :global or :project
+        def detect_scope
+          ctx = RosettAi.context
+          ctx.project? && !ctx.rai_internal? ? :project : :global
+        end
+
+        # @param scope [Symbol]
+        # @return [Pathname]
+        def resolve_source_dir(scope)
+          return RosettAi.root.join('conf') if RosettAi.context.rai_internal?
+
+          scope == :project ? RosettAi.conf_root.join('conf') : RosettAi.paths.rai_conf_dir
+        end
+
+        # @param backend [RosettAi::Compiler::Backend]
+        # @param scope [Symbol]
+        # @return [Pathname]
+        def resolve_target_dir(backend, scope)
+          dir = backend.profile.output_dir
+          return Pathname.new(File.expand_path(dir)) if dir
+
+          return RosettAi.context.project_root.join('.claude', 'rules') if scope == :project
+
+          RosettAi.paths.rules_dir
+        end
+
+        # @param scope [Symbol]
+        # @return [Array<Pathname>]
+        def additional_dirs(scope)
+          dirs = []
+          packaged = RosettAi.paths.packaged_conf_dir
+          dirs << packaged if packaged.directory?
+          dirs << RosettAi.paths.rai_conf_dir if scope == :project || RosettAi.context.rai_internal?
+          dirs
+        end
+
+        # @param pipeline [RosettAi::Compiler::CompilationPipeline]
+        # @param compiled [Hash]
+        # @param engine [String]
+        # @return [Hash]
+        def build_simulate_result(pipeline, compiled, engine)
+          files = compiled.map do |filename, info|
+            target = pipeline.target_dir.join(filename)
+            existing = File.exist?(target)
+            {
+              filename: filename,
+              exists: existing,
+              stale: existing ? !pipeline.diff(target, info[:content]).nil? : true
+            }
+          end
+
+          {
+            simulate: true,
+            engine: engine,
+            status: 'dry-run',
+            files: files,
+            total: compiled.size,
+            message: "Simulation complete — #{compiled.size} file(s), no files written"
+          }
+        end
+
+        # @param pipeline [RosettAi::Compiler::CompilationPipeline]
+        # @param compiled [Hash]
+        # @param engine [String]
+        # @return [Hash]
+        def build_write_result(pipeline, compiled, engine)
+          results = { created: [], updated: [], unchanged: [] }
+
+          compiled.each do |filename, info|
+            target = pipeline.target_dir.join(filename)
+            FileUtils.mkdir_p(target.dirname)
+            action = write_compiled_file(pipeline, target, info[:content])
+            results[action] << filename
+          end
+
+          {
+            simulate: false,
+            engine: engine,
+            status: 'compiled',
+            created: results[:created],
+            updated: results[:updated],
+            unchanged: results[:unchanged],
+            total: compiled.size,
+            message: "Compilation complete — #{results[:created].size} created, " \
+                     "#{results[:updated].size} updated, #{results[:unchanged].size} unchanged"
+          }
+        end
+
+        # @param pipeline [RosettAi::Compiler::CompilationPipeline]
+        # @param target [Pathname]
+        # @param content [String]
+        # @return [Symbol] :created, :updated, or :unchanged
+        def write_compiled_file(pipeline, target, content)
+          unless File.exist?(target)
+            File.write(target, content)
+            return :created
+          end
+
+          existing_checksum = pipeline.checksum(File.read(target, encoding: 'utf-8'))
+          new_checksum = pipeline.checksum(content)
+
+          if existing_checksum == new_checksum
+            :unchanged
+          else
+            File.write(target, content)
+            :updated
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# 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 rosett-ai compliance checks.
+      #
+      # Executes CRA, license, and SPDX header checks.
+      # Read-only operation — does not modify any files.
+      #
+      # @author hugo
+      # @author claude
+      class ComplyTool
+        TOOL_NAME = 'rai_comply'
+        DESCRIPTION = 'Run rosett-ai compliance checks (CRA, license, SPDX headers)'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            cra: {
+              type: 'boolean',
+              description: 'Run CRA-specific checks only (default: false)'
+            },
+            license: {
+              type: 'boolean',
+              description: 'Run license audit checks only (default: false)'
+            },
+            headers: {
+              type: 'boolean',
+              description: 'Run SPDX header checks only (default: false)'
+            },
+            format: {
+              type: 'string',
+              enum: ['json', 'text'],
+              description: 'Output format (default: json)'
+            }
+          }
+        }.freeze
+
+        # Executes compliance checks.
+        #
+        # @param cra [Boolean] run CRA checks only
+        # @param license [Boolean] run license checks only
+        # @param headers [Boolean] run SPDX header checks only
+        # @param format [String] output format ('json' or 'text')
+        # @return [Hash] compliance results
+        def call(cra: false, license: false, headers: false, format: 'json')
+          checks = filter_checks(cra: cra, license: license, headers: headers)
+          results = run_checks(checks)
+          violations = results.select { |r| r[:status] == 'fail' }
+          { compliant: violations.empty?, results: results, violations: violations, format: format }
+        rescue StandardError => e
+          ResponseHelper.error("Compliance check failed: #{e.message}")
+        end
+
+        private
+
+        def filter_checks(cra:, license:, headers:)
+          selected = { cra: cra, license: license, headers: headers }.select { |_, v| v }.keys
+          selected.empty? ? nil : selected
+        end
+
+        def run_checks(checks)
+          RosettAi::Comply::Runner.new(project_root: RosettAi.root, checks: checks).run
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# 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: compile Claude Code configuration.
+      #
+      # Compiles YAML scopes to JSON settings files.
+      # Requires an engine plugin with config compiler support.
+      #
+      # @author hugo
+      # @author claude
+      class ConfigCompileTool
+        TOOL_NAME = 'rai_config_compile'
+        DESCRIPTION = 'Compile rai configuration scopes to JSON settings'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            simulate: {
+              type: 'boolean',
+              description: 'Dry-run mode (default: true)'
+            },
+            scope: {
+              type: 'string',
+              description: 'Compile a specific scope only (e.g. managed, user, project)'
+            },
+            engine: {
+              type: 'string',
+              description: 'Target engine (default: claude)'
+            }
+          }
+        }.freeze
+
+        # Executes the configuration compilation.
+        #
+        # @param simulate [Boolean] dry-run mode
+        # @param scope [String, nil] specific scope to compile
+        # @param engine [String] target engine
+        # @return [Hash] compilation results
+        def call(simulate: true, scope: nil, engine: 'claude')
+          plugin = RosettAi::Plugins::Registry.plugin_module(:engine, engine)
+          compiler_class = plugin&.config_compiler_class
+          unless compiler_class
+            return ResponseHelper.error(
+              "Engine '#{engine}' has no config compiler. " \
+              'Install an engine plugin to enable config compilation.'
+            )
+          end
+
+          results = compiler_class.new(simulate: simulate).compile_all(scope: scope)
+          { simulate: simulate, scope: scope, engine: engine,
+            status: simulate ? 'dry-run' : 'compiled',
+            files: results[:files], message: results[:message] }
+        rescue StandardError => e
+          ResponseHelper.error("Config compile failed: #{e.message}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# 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 rai configuration status.
+      #
+      # Returns the current state of rai configuration including
+      # project info, engine status, and validation state.
+      #
+      # @author hugo
+      # @author claude
+      class ConfigStatusTool
+        TOOL_NAME = 'rai_config_status'
+        DESCRIPTION = 'Show rai configuration and project status'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => true,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => false
+        }.freeze
+
+        # Executes the status check.
+        #
+        # @return [Hash] result with configuration status
+        def call
+          {
+            version: RosettAi::VERSION,
+            project_root: RosettAi.root.to_s,
+            behaviours: count_files('conf/behaviour'),
+            designs: count_files('conf/design'),
+            engines: detect_engines,
+            default_engine: detect_default_engine,
+            scope: detect_scope
+          }
+        rescue StandardError => e
+          ResponseHelper.error("Config status failed: #{e.message}")
+        end
+
+        private
+
+        # @param subdir [String]
+        # @return [Integer]
+        def count_files(subdir)
+          dir = RosettAi.root.join(subdir)
+          dir.directory? ? dir.glob('*.yml').size : 0
+        end
+
+        # @return [Hash] engine count and any error
+        def detect_engines
+          registry = RosettAi::Plugins::Registry
+          count = registry.respond_to?(:discovered) ? registry.discovered.size : 0
+          { count: count }
+        rescue StandardError => e
+          { count: 0, error: e.message }
+        end
+
+        # @return [String] default engine name or error detail
+        def detect_default_engine
+          RosettAi.rai_config.default_engine
+        rescue StandardError => e
+          "unknown (#{e.message})"
+        end
+
+        # @return [String] detected compilation scope
+        def detect_scope
+          ctx = RosettAi.context
+          ctx.project? && !ctx.rai_internal? ? 'project' : 'global'
+        rescue StandardError
+          'unknown'
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/tools/content_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: manage content packs.
+      #
+      # List, install, or update content packs.
+      # Write operation for install/update actions.
+      #
+      # @author hugo
+      # @author claude
+      class ContentTool
+        TOOL_NAME = 'rai_content'
+        DESCRIPTION = 'List, install, or update rai content packs'
+
+        ANNOTATIONS = {
+          'readOnlyHint' => false,
+          'destructiveHint' => false,
+          'idempotentHint' => true,
+          'openWorldHint' => true
+        }.freeze
+
+        VALID_ACTIONS = ['list', 'install', 'update'].freeze
+
+        INPUT_SCHEMA = {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['list', 'install', 'update'],
+              description: 'Content action (default: list)'
+            },
+            pack_name: {
+              type: 'string',
+              description: 'Content pack name (required for install)'
+            }
+          }
+        }.freeze
+
+        # Executes the content pack operation.
+        #
+        # @param action [String] one of 'list', 'install', 'update'
+        # @param pack_name [String, nil] pack name for install
+        # @return [Hash] operation result
+        def call(action: 'list', pack_name: nil)
+          return ResponseHelper.error("Invalid action: #{action}") unless VALID_ACTIONS.include?(action)
+
+          case action
+          when 'list' then action_list
+          when 'install' then action_install(pack_name)
+          when 'update' then ResponseHelper.error('Content update requires CLI: raictl content update')
+          end
+        rescue StandardError => e
+          ResponseHelper.error("Content #{action} failed: #{e.message}")
+        end
+
+        private
+
+        def action_list
+          registry = RosettAi::Content::PackRegistry.new
+          { packs: registry.installed }
+        end
+
+        def action_install(pack_name)
+          return ResponseHelper.error('Pack name required for install') unless pack_name
+
+          ResponseHelper.error(
+            "Content install requires CLI with license key: raictl content install #{pack_name}"
+          )
+        end
+      end
+    end
+  end
+end