rosett-ai 1.3.3

data/lib/rosett_ai/thor/tasks/behaviour.rb

@@ -0,0 +1,474 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'thor'
+require 'terminal-table'
+require 'rainbow'
+require 'tty-prompt'
+require 'tty-spinner'
+require 'yaml'
+require 'securerandom'
+require 'fileutils'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Subcommand for managing behaviour files
+      # Must be defined before Behaviour class that references it
+      class BehaviourManage < ::Thor
+        desc 'add NAME', 'Create a new behaviour configuration file'
+        long_desc <<~LONGDESC
+          Creates a new behaviour YAML file in conf/behaviour/ with a template
+          structure. Opens the file in $EDITOR for customization, then validates
+          before saving.
+
+          EXAMPLES
+
+            raictl behaviour manage add security_rules
+            raictl behaviour manage add coding_standards --description "Coding standards" --author hugo
+        LONGDESC
+        method_option :description,
+                      type: :string,
+                      desc: 'Description of the behaviour'
+        method_option :author,
+                      type: :string,
+                      default: ENV.fetch('USER', 'unknown'),
+                      desc: 'Author of the behaviour file'
+
+        def add(name)
+          name = RosettAi::TextSanitizer.normalize_nfc(name)
+          return if behaviour_exists?(name)
+
+          description = options[:description] || RosettAi::Ui::TtyHelper.ask('Description:', option_hint: 'description')
+          temp_file, temp_dir = create_temp_behaviour(name, description, options[:author])
+
+          open_in_editor(temp_file)
+          return cleanup_temp(temp_dir) unless valid_behaviour?(temp_file)
+
+          save_behaviour(temp_file, name, temp_dir)
+        end
+
+        desc 'modify NAME', 'Modify an existing behaviour file'
+        long_desc <<~LONGDESC
+          Opens an existing behaviour file in $EDITOR for modification.
+          Automatically updates modified_at and modified_by metadata.
+          Validates the file before saving changes.
+
+          EXAMPLES
+
+            raictl behaviour manage modify security_rules
+        LONGDESC
+        def modify(name)
+          name = RosettAi::TextSanitizer.normalize_nfc(name)
+          file_path = find_behaviour_file(name)
+          raise ::Thor::Error, Rainbow(t('not_found', name: name)).red unless file_path
+
+          temp_file, temp_dir = create_temp_copy(file_path)
+          update_modification_metadata(temp_file)
+
+          open_in_editor(temp_file)
+          return cleanup_temp(temp_dir) unless valid_behaviour?(temp_file)
+
+          FileUtils.cp(temp_file, file_path)
+          cleanup_temp(temp_dir)
+          puts Rainbow(t('updated', name: name)).green
+        end
+
+        desc 'delete NAME', 'Delete a behaviour file'
+        long_desc <<~LONGDESC
+          Deletes a behaviour file after confirmation. Shows any references
+          to this behaviour in CLAUDE.md or compiled rules before prompting.
+
+          EXAMPLES
+
+            raictl behaviour manage delete obsolete_rules
+            raictl behaviour manage delete obsolete_rules --force
+        LONGDESC
+        method_option :force,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Skip confirmation'
+
+        def delete(name)
+          name = RosettAi::TextSanitizer.normalize_nfc(name)
+          file_path = find_behaviour_file(name)
+          raise ::Thor::Error, Rainbow(t('not_found', name: name)).red unless file_path
+
+          display_usages(name)
+          return unless deletion_confirmed?(name)
+
+          File.delete(file_path)
+          cleanup_compiled_rules(name)
+          puts Rainbow(t('deleted', name: name)).green
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.behaviour.#{key}", **)
+        end
+
+        def behaviour_exists?(name)
+          existing = find_behaviour_file(name)
+          return false unless existing
+
+          puts Rainbow(t('already_exists', name: name, path: existing)).red
+          true
+        end
+
+        def create_temp_behaviour(name, description, author)
+          temp_dir = File.join('/tmp', SecureRandom.uuid)
+          FileUtils.mkdir_p(temp_dir)
+          temp_file = File.join(temp_dir, "#{name}.yml")
+          File.open(temp_file, 'w', 0o644) { |f| f.write(generate_template(name, description, author)) }
+          [temp_file, temp_dir]
+        end
+
+        def create_temp_copy(file_path)
+          temp_dir = File.join('/tmp', SecureRandom.uuid)
+          FileUtils.mkdir_p(temp_dir)
+          temp_file = File.join(temp_dir, File.basename(file_path))
+          FileUtils.cp(file_path, temp_file)
+          [temp_file, temp_dir]
+        end
+
+        def update_modification_metadata(temp_file)
+          text = File.read(temp_file)
+          today = Date.today.to_s
+          user = ENV.fetch('USER', 'unknown')
+          text = text.sub(/^(modified_at:\s*).*$/, "\\1\"#{today}\"")
+          text = text.sub(/^(modified_by:\s*).*$/, "\\1#{user}")
+          File.open(temp_file, 'w', 0o644) { |f| f.write(text) }
+        end
+
+        def open_in_editor(file)
+          system(ENV.fetch('EDITOR', 'vim'), file)
+        end
+
+        def valid_behaviour?(temp_file)
+          validator = RosettAi::Validators::BehaviourValidator.new
+          return true if validator.valid?(temp_file)
+
+          puts Rainbow(t('validation_failed_label')).red
+          validator.errors.each { |err| puts "  #{err}" }
+          false
+        end
+
+        def cleanup_temp(temp_dir)
+          FileUtils.rm_rf(temp_dir)
+        end
+
+        def save_behaviour(temp_file, name, temp_dir)
+          dest = behaviour_path.join("#{name}.yml")
+          FileUtils.cp(temp_file, dest)
+          cleanup_temp(temp_dir)
+          puts Rainbow(t('created', name: name, path: dest)).green
+        end
+
+        def generate_template(name, description, author)
+          {
+            'name' => name,
+            'description' => description,
+            'version' => '1.0.0',
+            'author' => author,
+            'created_at' => Date.today.to_s,
+            'modified_at' => Date.today.to_s,
+            'modified_by' => author,
+            'used_in' => [],
+            'rules' => [
+              {
+                'id' => 'rule_001',
+                'description' => 'Example rule - replace with actual rule',
+                'priority' => 50,
+                'enabled' => true
+              }
+            ]
+          }.to_yaml
+        end
+
+        # Write target for manage operations — always XDG user path.
+        def behaviour_path
+          RosettAi.paths.rai_conf_dir.join('behaviour')
+        end
+
+        # Search chain for finding existing files.
+        def find_behaviour_file(name)
+          [behaviour_path,
+           RosettAi.paths.packaged_conf_dir.join('behaviour')].each do |dir|
+            path = dir.join("#{name}.yml")
+            return path.to_s if path.exist?
+          end
+          nil
+        end
+
+        def display_usages(name)
+          usages = find_usages(name)
+          return if usages.empty?
+
+          puts Rainbow(t('referenced_in')).yellow
+          usages.each { |usage| puts "  #{usage}" }
+        end
+
+        def deletion_confirmed?(name)
+          RosettAi::Ui::TtyHelper.confirm?(t('delete_confirm', name: name), force: options[:force])
+        end
+
+        def find_usages(name)
+          usages = []
+          usages.concat(find_claude_md_usages(name))
+          usages.concat(find_rules_usages(name))
+          usages
+        end
+
+        def find_claude_md_usages(name)
+          claude_md = RosettAi.root.join('CLAUDE.md')
+          return [] unless claude_md.exist? && claude_md.read.include?(name)
+
+          ['CLAUDE.md']
+        end
+
+        def find_rules_usages(name)
+          Dir.glob(RosettAi.root.join('rules', '*')).each_with_object([]) do |rule_file, usages|
+            next unless File.file?(rule_file) && File.read(rule_file).include?(name)
+
+            usages << "rules/#{File.basename(rule_file)}"
+          end
+        end
+
+        def cleanup_compiled_rules(name)
+          rules_dir = RosettAi.paths.rules_dir
+          return unless rules_dir.exist?
+
+          Dir.glob(rules_dir.join("behaviour-#{name}.*")).each do |compiled|
+            next unless managed_compiled_file?(compiled)
+
+            File.delete(compiled)
+          end
+        rescue Errno::ENOENT
+          # Race condition: file deleted between glob and delete
+        end
+
+        def managed_compiled_file?(path)
+          first_line = File.open(path, &:readline)
+          first_line.include?('rosett-ai-') && first_line.include?('managed')
+        rescue EOFError, Errno::ENOENT
+          false
+        end
+      end
+
+      # Behaviour configuration management tasks
+      class Behaviour < ::Thor
+        desc 'display', 'Show current behaviour configuration'
+        long_desc <<~LONGDESC
+          Displays all behaviour files in a summary table with name, file,
+          modification date, usage references, and author. Supports JSON and
+          YAML output for scripting.
+
+          EXAMPLES
+
+            raictl behaviour display
+            raictl behaviour display --format json
+            raictl behaviour display --format yaml
+        LONGDESC
+        method_option :format,
+                      type: :string,
+                      default: 'table',
+                      enum: ['table', 'json', 'yaml'],
+                      desc: 'Output format'
+
+        def display
+          behaviours = load_all_behaviours
+
+          if behaviours.empty?
+            puts Rainbow(t('no_files')).yellow
+            return
+          end
+
+          sanitized = RosettAi::TextSanitizer.sanitize_for_display(behaviours)
+          case options[:format]
+          when 'json'
+            puts JSON.pretty_generate(sanitized)
+          when 'yaml'
+            puts sanitized.to_yaml
+          else
+            display_table(sanitized)
+          end
+        end
+
+        desc 'list', 'List all behaviour files'
+        long_desc <<~LONGDESC
+          Lists all behaviour YAML files found in the conf/behaviour/ directory.
+          Shows file names without the .yml extension.
+
+          EXAMPLES
+
+            raictl behaviour list
+        LONGDESC
+        def list
+          files = behaviour_files
+          if files.empty?
+            puts Rainbow(t('no_files_short')).yellow
+            return
+          end
+
+          puts Rainbow(t('files_title')).bright
+          files.each do |file|
+            puts "  #{Rainbow(File.basename(file, '.yml')).cyan}"
+          end
+        end
+
+        desc 'show NAME', 'Show details of a specific behaviour file'
+        long_desc <<~LONGDESC
+          Displays the full YAML content of a named behaviour file, including
+          all rules, metadata, and usage references.
+
+          EXAMPLES
+
+            raictl behaviour show code_generation
+            raictl behaviour show security_rules
+        LONGDESC
+        def show(name)
+          name = RosettAi::TextSanitizer.normalize_nfc(name)
+          file_path = find_behaviour_file(name)
+          raise ::Thor::Error, Rainbow(t('not_found', name: name)).red unless file_path
+
+          content = RosettAi::YamlLoader.load_file(file_path)
+          puts YAML.dump(RosettAi::TextSanitizer.sanitize_for_display(content))
+        rescue Psych::SyntaxError => e
+          raise ::Thor::Error, Rainbow(t('yaml_syntax_error', path: file_path, detail: e.message)).red
+        end
+
+        desc 'validate [NAME]', 'Validate behaviour file(s)'
+        long_desc <<~LONGDESC
+          Validates behaviour files against the behaviour JSON schema.
+          If NAME is given, validates only that file; otherwise validates all
+          files in conf/behaviour/.
+
+          Exit codes: 0 = all valid, 1 = validation failures.
+
+          EXAMPLES
+
+            raictl behaviour validate
+            raictl behaviour validate code_generation
+        LONGDESC
+        def validate(name = nil)
+          name = RosettAi::TextSanitizer.normalize_nfc(name) if name
+          files = files_to_validate(name)
+          return puts Rainbow(t('no_validate')).yellow if files.empty?
+
+          all_valid = validate_files(files)
+          raise ::Thor::Error, t('validation_failed') unless all_valid
+        end
+
+        desc 'manage SUBCOMMAND', 'Add, modify, or delete behaviour files'
+        subcommand 'manage', BehaviourManage
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.behaviour.#{key}", **)
+        end
+
+        # Aggregates behaviour files from all lookup dirs.
+        # Later dirs are lower priority — files with duplicate basenames
+        # are omitted (user overrides packaged defaults).
+        def behaviour_files
+          seen = {}
+          behaviour_search_dirs.each do |dir|
+            Dir.glob(dir.join('*.yml')).each do |f|
+              base = File.basename(f)
+              seen[base] ||= f
+            end
+          end
+          seen.values
+        end
+
+        # Lookup chain: (1) project-local, (2) XDG user, (3) packaged defaults.
+        def behaviour_search_dirs
+          dirs = []
+          dirs << RosettAi.conf_root.join('conf', 'behaviour') if RosettAi.context.project?
+          dirs << RosettAi.paths.rai_conf_dir.join('behaviour')
+          dirs << RosettAi.paths.packaged_conf_dir.join('behaviour')
+          dirs.select(&:directory?)
+        end
+
+        def find_behaviour_file(name)
+          behaviour_search_dirs.each do |dir|
+            path = dir.join("#{name}.yml")
+            return path.to_s if path.exist?
+          end
+          nil
+        end
+
+        def files_to_validate(name)
+          return behaviour_files unless name
+
+          [find_behaviour_file(name)].compact
+        end
+
+        def validate_files(files)
+          validator = RosettAi::Validators::BehaviourValidator.new
+          files.all? { |file| file_valid?(validator, file) }
+        end
+
+        def file_valid?(validator, file)
+          basename = File.basename(file)
+          if validator.valid?(file)
+            puts "#{Rainbow(t('valid')).green}   #{basename}"
+            true
+          else
+            display_validation_errors(basename, validator.errors)
+            false
+          end
+        end
+
+        def display_validation_errors(basename, errors)
+          puts "#{Rainbow(t('invalid')).red} #{basename}"
+          errors.each { |err| puts "         #{err}" }
+        end
+
+        def load_all_behaviours
+          behaviour_files.map do |file|
+            content = RosettAi::YamlLoader.load_file(file)
+            content['_file'] = File.basename(file)
+            content
+          rescue StandardError => e
+            { '_file' => File.basename(file), '_error' => e.message }
+          end
+        end
+
+        def display_table(behaviours)
+          rows = behaviours.map { |behaviour| build_table_row(behaviour) }
+          puts build_behaviour_table(rows)
+        end
+
+        def build_table_row(behaviour)
+          [
+            behaviour['name'] || behaviour['_file'],
+            behaviour['_file'],
+            behaviour['modified_at'] || '-',
+            format_used_in(behaviour['used_in']),
+            behaviour['modified_by'] || '-'
+          ]
+        end
+
+        def format_used_in(used_in_list)
+          return '-' if used_in_list.to_a.empty?
+
+          used_in_list.join(', ')
+        end
+
+        def build_behaviour_table(rows)
+          ::Terminal::Table.new(
+            title: Rainbow(t('table_title')).bright,
+            headings: ['Name', 'File', 'Date Modified', 'Used In', 'Modified By'],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+        end
+      end
+    end
+  end
+end