rosett-ai 1.3.3

data/lib/rosett_ai/migration/detector.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 Migration
+    # Detects configuration files that need migration to the current schema.
+    #
+    # Scans behaviour YAML, design YAML, and rai config files for
+    # deprecated patterns or missing required fields. Returns structured
+    # findings that CLI commands can display to the user.
+    #
+    # @author hugo
+    # @author claude
+    # @see conf/design/backward_compatibility.yml
+    class Detector
+      # @return [Pathname] configuration directory to scan
+      attr_reader :config_dir
+
+      # @param config_dir [Pathname, String] configuration root to scan
+      def initialize(config_dir:)
+        @config_dir = Pathname.new(config_dir)
+      end
+
+      # Scan all config files and return migration findings.
+      #
+      # @return [Array<Hash{Symbol => String}>] list of findings with
+      #   :file, :type, :field, and :message keys
+      def detect
+        findings = []
+        findings.concat(scan_behaviour_files)
+        findings.concat(scan_design_files)
+        findings
+      end
+
+      # Convenience check for whether any migrations are needed.
+      #
+      # @return [Boolean]
+      def migrations_needed?
+        detect.any?
+      end
+
+      private
+
+      def scan_behaviour_files
+        behaviour_dir = config_dir.join('behaviour')
+        return [] unless behaviour_dir.directory?
+
+        scan_directory(behaviour_dir, method(:check_behaviour))
+      end
+
+      def scan_design_files
+        design_dir = config_dir.join('design')
+        return [] unless design_dir.directory?
+
+        scan_directory(design_dir, method(:check_design))
+      end
+
+      def scan_directory(dir, checker)
+        findings = []
+        Dir.glob(dir.join('*.yml').to_s).each do |path|
+          data = load_yaml(path)
+          next unless data.is_a?(Hash)
+
+          checker.call(path, data, findings)
+        end
+        findings
+      end
+
+      def check_behaviour(path, data, findings)
+        check_missing_field(path, data, 'version', findings)
+        check_missing_field(path, data, 'rules', findings)
+        check_deprecated_field(path, data, 'target', 'engine', findings)
+      end
+
+      def check_design(path, data, findings)
+        check_missing_field(path, data, 'domain', findings)
+        check_missing_field(path, data, 'status', findings)
+        check_deprecated_field(path, data, 'target', 'engine', findings)
+      end
+
+      def check_missing_field(path, data, field, findings)
+        return if data.key?(field)
+
+        findings << build_finding(
+          file: path,
+          type: :missing_field,
+          field: field,
+          message: ::I18n.t('rosett_ai.migration.missing_field', field: field, file: path)
+        )
+      end
+
+      def check_deprecated_field(path, data, old_field, new_field, findings)
+        return unless data.key?(old_field)
+
+        findings << build_finding(
+          file: path,
+          type: :deprecated_field,
+          field: old_field,
+          message: ::I18n.t('rosett_ai.migration.deprecated_field',
+                            field: old_field, replacement: new_field, file: path)
+        )
+      end
+
+      def build_finding(file:, type:, field:, message:)
+        { file: file, type: type, field: field, message: message }
+      end
+
+      def load_yaml(path)
+        YAML.safe_load_file(path, permitted_classes: [Date])
+      rescue Psych::SyntaxError, Errno::ENOENT
+        nil
+      end
+    end
+  end
+end

data/lib/rosett_ai/migration/nncc_config_migrator.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 'fileutils'
+
+module RosettAi
+  module Migration
+    # Migrates legacy ~/.config/nncc/ to ~/.config/rosett-ai/.
+    #
+    # Steps:
+    # 1. Detect ~/.config/nncc/ existence
+    # 2. Copy contents to ~/.config/rosett-ai/
+    # 3. Rename source to ~/.config/nncc.migrated-<date>/
+    # 4. Verify the copy succeeded
+    #
+    # @author hugo
+    # @author claude
+    class NnccConfigMigrator
+      DEFAULT_SOURCE = '~/.config/nncc'
+      DEFAULT_TARGET = '~/.config/rosett-ai'
+
+      attr_reader :source, :target, :migrated
+
+      def initialize(source: DEFAULT_SOURCE, target: DEFAULT_TARGET)
+        @source = Pathname.new(File.expand_path(source))
+        @target = Pathname.new(File.expand_path(target))
+        @migrated = []
+      end
+
+      # @return [Boolean] true if legacy config directory exists
+      def migration_needed?
+        source.directory? && !source.basename.to_s.include?('.migrated-')
+      end
+
+      # Performs the migration.
+      #
+      # @return [Array<String>] list of migrated relative paths
+      def migrate!
+        @migrated = []
+        return @migrated unless migration_needed?
+
+        FileUtils.mkdir_p(target)
+        copy_tree(source, target)
+        mark_source_migrated
+        @migrated
+      end
+
+      # Returns a plan of what will be migrated.
+      #
+      # @return [Array<Hash>] list of files with :path and :size keys
+      def plan
+        return [] unless migration_needed?
+
+        source.glob('**/*').select(&:file?).map do |file|
+          rel = file.relative_path_from(source).to_s
+          { path: rel, size: file.size }
+        end
+      end
+
+      private
+
+      def copy_tree(src, dst)
+        src.children.each do |entry|
+          dest_path = dst.join(entry.basename)
+          copy_entry(entry, dest_path)
+        end
+      end
+
+      def copy_entry(entry, dest_path)
+        if entry.directory?
+          FileUtils.mkdir_p(dest_path)
+          copy_tree(entry, dest_path)
+        elsif !dest_path.exist?
+          FileUtils.cp(entry.to_s, dest_path.to_s)
+          @migrated << entry.relative_path_from(source).to_s
+        end
+      end
+
+      def mark_source_migrated
+        return if @migrated.empty?
+
+        date_suffix = Time.now.strftime('%Y%m%d')
+        migrated_path = source.parent.join("nncc.migrated-#{date_suffix}")
+        return if migrated_path.exist?
+
+        FileUtils.mv(source.to_s, migrated_path.to_s)
+      rescue Errno::EACCES => e
+        RosettAi.logger.warn("Cannot rename legacy config dir: #{e.message}")
+      end
+    end
+  end
+end

data/lib/rosett_ai/migration/nncc_project_migrator.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'fileutils'
+
+module RosettAi
+  module Migration
+    # Migrates legacy .nncc/ project directories to .rosett-ai/.
+    #
+    # Can operate on a single project root or scan an entire workspace
+    # for projects containing .nncc/ directories.
+    #
+    # @author hugo
+    # @author claude
+    class NnccProjectMigrator
+      attr_reader :results
+
+      def initialize
+        @results = []
+      end
+
+      # Migrate a single project's .nncc/ to .rosett-ai/.
+      #
+      # @param project_root [Pathname, String] path to project root
+      # @return [Hash] result with :path, :status, :message keys
+      def migrate_project(project_root)
+        root = Pathname.new(project_root)
+        perform_migration(root)
+      rescue Errno::EACCES => e
+        record_result(root, :error, "Permission denied: #{e.message}")
+      end
+
+      # Scan a workspace for projects with .nncc/ and migrate them.
+      #
+      # @param workspace [Pathname, String] root directory to scan
+      # @return [Array<Hash>] results for each project found
+      def migrate_workspace(workspace)
+        find_nncc_projects(workspace).each { |path| migrate_project(path) }
+        @results
+      end
+
+      # Detect projects with .nncc/ in a workspace (dry-run).
+      #
+      # @param workspace [Pathname, String] root directory to scan
+      # @return [Array<String>] list of project paths with .nncc/
+      def detect(workspace)
+        find_nncc_projects(workspace)
+      end
+
+      private
+
+      def perform_migration(root)
+        nncc_dir = root.join('.nncc')
+        rosett_dir = root.join('.rosett-ai')
+
+        return record_result(root, :skipped, 'No .nncc/ directory found') unless nncc_dir.directory?
+        return record_result(root, :skipped, '.rosett-ai/ already exists') if rosett_dir.directory?
+
+        FileUtils.mv(nncc_dir.to_s, rosett_dir.to_s)
+        update_config_yml(rosett_dir)
+        record_result(root, :migrated, '.nncc/ renamed to .rosett-ai/')
+      end
+
+      def find_nncc_projects(workspace)
+        Dir.glob(Pathname.new(workspace).join('**', '.nncc'), File::FNM_DOTMATCH).map do |nncc_path|
+          File.dirname(nncc_path)
+        end
+      end
+
+      def record_result(root, status, message)
+        result = { path: root.to_s, status: status, message: message }
+        @results << result
+        result
+      end
+
+      def update_config_yml(rosett_dir)
+        config = rosett_dir.join('config.yml')
+        return unless config.exist?
+
+        content = File.read(config)
+        updated = content.gsub('.nncc', '.rosett-ai').gsub(/\bnncc\b/, 'rosett-ai')
+        return if content == updated
+
+        File.write(config, updated)
+      end
+    end
+  end
+end

data/lib/rosett_ai/migration/xdg_migrator.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'fileutils'
+
+module RosettAi
+  module Migration
+    # Migrates behaviour/schema files from legacy ~/.claude/conf/ to
+    # XDG-compliant ~/.config/rosett-ai/conf/.
+    #
+    # Created after WP#943: global compile scope was reading from the
+    # installation directory because init placed files at ~/.claude/conf/
+    # instead of the XDG path specified in scope_hierarchy.yml.
+    class XdgMigrator
+      LEGACY_CONF = File.expand_path('~/.claude/conf')
+      MIGRATED_SUFFIX = '.migrated-to-xdg'
+
+      attr_reader :legacy_dir, :xdg_dir, :migrated
+
+      def initialize
+        @legacy_dir = Pathname.new(LEGACY_CONF)
+        @xdg_dir = RosettAi.paths.rai_conf_dir
+        @migrated = []
+      end
+
+      # Detects whether migration is needed.
+      #
+      # @return [Boolean] true if legacy dir has files and XDG dir is empty/missing
+      def migration_needed?
+        return false unless legacy_dir.join('behaviour').exist?
+        return false if legacy_dir.basename.to_s.end_with?(MIGRATED_SUFFIX)
+
+        legacy_files = Dir.glob(legacy_dir.join('behaviour', '*.yml'))
+        return false if legacy_files.empty?
+
+        xdg_files = xdg_dir.join('behaviour').exist? ? Dir.glob(xdg_dir.join('behaviour', '*.yml')) : []
+        xdg_files.empty? || legacy_has_newer_files?(legacy_files, xdg_files)
+      end
+
+      # Performs the migration: copy files, then rename legacy directory.
+      #
+      # @return [Array<String>] list of migrated file basenames
+      def migrate!
+        @migrated = []
+        FileUtils.mkdir_p(xdg_dir.join('behaviour'))
+        FileUtils.mkdir_p(xdg_dir.join('schemas'))
+
+        migrate_directory('behaviour', '*.yml')
+        migrate_directory('schemas', '*.json')
+        migrate_file('adopt_redactions.yml')
+
+        mark_legacy_migrated
+        @migrated
+      end
+
+      # Returns a user-facing warning message about the pending migration.
+      #
+      # @return [String] warning text
+      def warning_message
+        legacy_count = Dir.glob(legacy_dir.join('behaviour', '*.yml')).size
+        <<~MSG.strip
+          [MIGRATION] Found #{legacy_count} behaviour file(s) at legacy path:
+            #{legacy_dir}/behaviour/
+          These will be migrated to XDG-compliant path:
+            #{xdg_dir}/behaviour/
+          Original files will be preserved at #{legacy_dir}#{MIGRATED_SUFFIX}/
+        MSG
+      end
+
+      private
+
+      def legacy_has_newer_files?(legacy_files, xdg_files)
+        xdg_names = xdg_files.map { |f| File.basename(f) }
+        legacy_files.any? { |f| !xdg_names.include?(File.basename(f)) }
+      end
+
+      def migrate_directory(subdir, pattern)
+        source = legacy_dir.join(subdir)
+        return unless source.exist?
+
+        target_dir = xdg_dir.join(subdir)
+        FileUtils.mkdir_p(target_dir)
+
+        Dir.glob(source.join(pattern)).each do |file|
+          basename = File.basename(file)
+          target = target_dir.join(basename)
+
+          if target.exist?
+            RosettAi.logger.debug("XDG migration: #{subdir}/#{basename} already exists, skipping")
+            next
+          end
+
+          FileUtils.cp(file, target)
+          @migrated << "#{subdir}/#{basename}"
+        end
+      end
+
+      def migrate_file(filename)
+        source = legacy_dir.join(filename)
+        return unless source.exist?
+
+        target = xdg_dir.join(filename)
+        return if target.exist?
+
+        FileUtils.cp(source.to_s, target.to_s)
+        @migrated << filename
+      end
+
+      def mark_legacy_migrated
+        return if @migrated.empty?
+
+        migrated_path = Pathname.new("#{legacy_dir}#{MIGRATED_SUFFIX}")
+        return if migrated_path.exist?
+
+        FileUtils.mv(legacy_dir.to_s, migrated_path.to_s)
+      rescue Errno::EACCES => e
+        RosettAi.logger.warn("Cannot rename legacy conf dir: #{e.message}")
+      end
+    end
+  end
+end

data/lib/rosett_ai/package_manager/apt.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module PackageManager
+    # APT package manager backend for Debian-based systems.
+    #
+    # Uses pkexec for privilege escalation (install/remove).
+    # All commands use array-form system() for security.
+    #
+    # @author hugo
+    # @author claude
+    class Apt < Base
+      DPKG_QUERY = 'dpkg-query'
+      APT_CACHE = 'apt-cache'
+      PKEXEC = 'pkexec'
+      APT_GET = 'apt-get'
+
+      # @return [String]
+      def backend_name
+        'apt'
+      end
+
+      # @return [Boolean]
+      def available?
+        system(DPKG_QUERY, '--version', out: File::NULL, err: File::NULL) == true
+      end
+
+      # Install a .deb package via pkexec + apt-get.
+      #
+      # @param package_name [String]
+      # @return [Boolean]
+      def install(package_name)
+        validate_package_name!(package_name)
+        system(PKEXEC, APT_GET, 'install', '-y', package_name, out: File::NULL)
+      end
+
+      # Remove a .deb package via pkexec + apt-get.
+      #
+      # @param package_name [String]
+      # @return [Boolean]
+      def remove(package_name)
+        validate_package_name!(package_name)
+        system(PKEXEC, APT_GET, 'remove', '-y', package_name, out: File::NULL)
+      end
+
+      # Check if a .deb package is installed via dpkg-query.
+      #
+      # @param package_name [String]
+      # @return [Boolean]
+      def installed?(package_name)
+        validate_package_name!(package_name)
+        system(DPKG_QUERY, '-W', '-f', '${Status}', package_name,
+               out: File::NULL, err: File::NULL) == true
+      end
+
+      # Search for available .deb packages via apt-cache.
+      #
+      # @param pattern [String]
+      # @return [Array<Hash>]
+      def available_packages(pattern)
+        validate_package_name!(pattern)
+        output = run_command(APT_CACHE, 'search', pattern)
+        return [] unless output
+
+        output.each_line.filter_map do |line|
+          name, description = line.strip.split(' - ', 2)
+          next unless name && description
+
+          { name: name.strip, description: description.strip }
+        end
+      end
+
+      # Update APT index via pkexec + apt-get.
+      #
+      # @return [Boolean]
+      def update_index
+        system(PKEXEC, APT_GET, 'update', out: File::NULL)
+      end
+
+      private
+
+      # Validate package name to prevent command injection.
+      # Debian package names: lowercase letters, digits, +, -, .
+      #
+      # @param name [String]
+      # @raise [PackageManagerError] if invalid
+      def validate_package_name!(name)
+        return if name.match?(/\A[a-z0-9][a-z0-9.+-]*\z/)
+
+        raise PackageManagerError, "Invalid package name: #{name}"
+      end
+
+      # Run a command and capture stdout.
+      #
+      # @return [String, nil] stdout or nil on failure
+      def run_command(*)
+        require 'open3'
+        stdout, _status = Open3.capture2(*)
+        stdout
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rosett_ai/package_manager/base.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module PackageManager
+    # Abstract base class for system package management.
+    #
+    # Concrete implementations handle apt (Debian) and gem backends.
+    # All backends use array-form system() for security.
+    #
+    # @author hugo
+    # @author claude
+    class Base
+      class PackageManagerError < RosettAi::Error; end
+
+      # Install a package by name.
+      #
+      # @param package_name [String] package to install
+      # @return [Boolean] true if installed successfully
+      def install(package_name)
+        raise NotImplementedError, "#{self.class}#install must be implemented"
+      end
+
+      # Remove a package by name.
+      #
+      # @param package_name [String] package to remove
+      # @return [Boolean] true if removed successfully
+      def remove(package_name)
+        raise NotImplementedError, "#{self.class}#remove must be implemented"
+      end
+
+      # Check if a package is installed.
+      #
+      # @param package_name [String] package to check
+      # @return [Boolean]
+      def installed?(package_name)
+        raise NotImplementedError, "#{self.class}#installed? must be implemented"
+      end
+
+      # Search for available packages matching a pattern.
+      #
+      # @param pattern [String] search pattern
+      # @return [Array<Hash>] matching packages with :name and :version keys
+      def available_packages(pattern)
+        raise NotImplementedError, "#{self.class}#available_packages must be implemented"
+      end
+
+      # Update the package index.
+      #
+      # @return [Boolean] true if updated successfully
+      def update_index
+        raise NotImplementedError, "#{self.class}#update_index must be implemented"
+      end
+
+      # @return [String] backend identifier
+      def backend_name
+        raise NotImplementedError, "#{self.class}#backend_name must be implemented"
+      end
+
+      # @return [Boolean] true if this backend is available on the system
+      def available?
+        raise NotImplementedError, "#{self.class}#available? must be implemented"
+      end
+    end
+  end
+end

data/lib/rosett_ai/package_manager/gem_backend.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module PackageManager
+    # RubyGems package manager backend.
+    #
+    # Does NOT require privilege escalation. Installs gems into
+    # the user's gem directory or the system gem path.
+    #
+    # @author hugo
+    # @author claude
+    class GemBackend < Base
+      GEM_COMMAND = 'gem'
+
+      # @return [String]
+      def backend_name
+        'gem'
+      end
+
+      # @return [Boolean]
+      def available?
+        defined?(::Gem) == 'constant'
+      end
+
+      # Install a gem.
+      #
+      # @param package_name [String]
+      # @return [Boolean]
+      def install(package_name)
+        validate_gem_name!(package_name)
+        system(GEM_COMMAND, 'install', package_name, '--no-document', out: File::NULL)
+      end
+
+      # Remove a gem.
+      #
+      # @param package_name [String]
+      # @return [Boolean]
+      def remove(package_name)
+        validate_gem_name!(package_name)
+        system(GEM_COMMAND, 'uninstall', package_name, '-x', out: File::NULL)
+      end
+
+      # Check if a gem is installed.
+      #
+      # @param package_name [String]
+      # @return [Boolean]
+      def installed?(package_name)
+        validate_gem_name!(package_name)
+        !Gem::Specification.find_all_by_name(package_name).empty?
+      rescue Gem::MissingSpecError
+        false
+      end
+
+      # Search for available gems matching a pattern.
+      #
+      # @param pattern [String]
+      # @return [Array<Hash>]
+      def available_packages(pattern)
+        validate_gem_name!(pattern)
+        specs = Gem::Specification.find_all_by_name(/#{Regexp.escape(pattern)}/)
+        specs.map { |s| { name: s.name, version: s.version.to_s } }
+      rescue Gem::MissingSpecError
+        []
+      end
+
+      # No-op for gems (no index to update).
+      #
+      # @return [Boolean]
+      def update_index # rubocop:disable Naming/PredicateMethod -- imperative action (Base interface), not a predicate
+        true
+      end
+
+      private
+
+      # Validate gem name to prevent abuse.
+      # Gem names: alphanumeric, hyphens, underscores.
+      #
+      # @param name [String]
+      # @raise [PackageManagerError] if invalid
+      def validate_gem_name!(name)
+        return if name.match?(/\A[a-zA-Z0-9][a-zA-Z0-9._-]*\z/)
+
+        raise PackageManagerError, "Invalid gem name: #{name}"
+      end
+    end
+  end
+end