rosett-ai 1.3.3

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

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'json'
+require 'thor'
+require 'rainbow'
+require 'terminal-table'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor task for D-Bus service management.
+      #
+      # Exit codes:
+      #   0 — success
+      #   1 — D-Bus connection failure
+      #   5 — missing ruby-dbus dependency
+      #
+      # @author hugo
+      # @author claude
+      class DBus < ::Thor
+        EXIT_SUCCESS = 0
+        EXIT_DBUS_FAILURE = 1
+        EXIT_MISSING_DEPENDENCY = 5
+
+        ENV_VARS = [
+          'SWAYSOCK', 'I3SOCK', 'HYPRLAND_INSTANCE_SIGNATURE', 'DISPLAY', 'WAYLAND_DISPLAY', 'XDG_RUNTIME_DIR', 'XDG_SESSION_TYPE'
+        ].freeze
+
+        ADAPTER_MAP = {
+          sway: 'I3Adapter (i3ipc)',
+          i3: 'I3Adapter (i3ipc)',
+          hyprland: 'HyprlandAdapter (socket2)',
+          gnome: 'GnomeAdapter (Shell D-Bus)',
+          kwin: 'KwinAdapter (KWin D-Bus)',
+          x11: 'X11Adapter (xprop)'
+        }.freeze
+
+        desc 'status', 'Show D-Bus service status'
+        long_desc <<~LONGDESC
+          Checks if the be.neatnerds.rosettai D-Bus service is running and displays status.
+          Output format depends on TTY detection (table or JSON).
+
+          Exit codes:
+            0: success
+            1: D-Bus connection failure
+            5: missing ruby-dbus gem
+
+          EXAMPLES
+
+            raictl dbus status
+
+          Related commands: raictl dbus start, rai dbus detect
+        LONGDESC
+        def status
+          require_desktop_gems!
+          check_dbus_availability
+
+          if service_running?
+            print_running_status
+          else
+            print_not_running
+          end
+        end
+
+        desc 'start', 'Start the D-Bus service (foreground)'
+        long_desc <<~LONGDESC
+          Starts the be.neatnerds.rosettai D-Bus service for focus tracking and IPC.
+          By default runs in foreground. Use --daemonize to run as background daemon.
+
+          Flags:
+            --daemonize, -d: Run as daemon (background)
+
+          Exit codes:
+            0: success
+            1: D-Bus connection failure or service already running
+            5: missing ruby-dbus gem
+
+          EXAMPLES
+
+            raictl dbus start
+            raictl dbus start --daemonize
+
+          Related commands: raictl dbus status, rai dbus stop
+        LONGDESC
+        method_option :daemonize,
+                      type: :boolean,
+                      default: false,
+                      aliases: '-d',
+                      desc: 'Run as daemon (background)'
+        def start
+          require_desktop_gems!
+          check_dbus_availability
+
+          if service_running?
+            warn Rainbow(t('already_running')).yellow
+            return
+          end
+
+          if options[:daemonize]
+            start_daemon
+          else
+            start_foreground
+          end
+        end
+
+        desc 'stop', 'Stop the D-Bus service'
+        long_desc <<~LONGDESC
+          Stops the running be.neatnerds.rosettai D-Bus service via D-Bus shutdown signal.
+
+          Exit codes:
+            0: success
+            1: D-Bus connection failure
+            5: missing ruby-dbus gem
+
+          EXAMPLES
+
+            raictl dbus stop
+
+          Related commands: raictl dbus start, rai dbus status
+        LONGDESC
+        def stop
+          require_desktop_gems!
+          unless service_running?
+            warn Rainbow(t('not_running')).yellow
+            return
+          end
+
+          stop_via_dbus
+          warn Rainbow(t('stopped')).green
+        end
+
+        desc 'detect', 'Detect compositor and show focus adapter'
+        long_desc <<~LONGDESC
+          Detects the running compositor (Sway, i3, Hyprland, GNOME, KWin, X11) and displays
+          the corresponding focus tracking adapter. Shows environment variables used for detection.
+
+          Output format depends on TTY detection (table or JSON).
+
+          EXAMPLES
+
+            raictl dbus detect
+
+          Related commands: raictl dbus status, rai dbus start
+        LONGDESC
+        def detect
+          require_desktop_gems!
+          compositor = RosettAi::DBus::CompositorDetector.detect
+
+          if tty_output?
+            print_detect_tty(compositor)
+          else
+            print_detect_json(compositor)
+          end
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.dbus.#{key}", **)
+        end
+
+        def tty_output?
+          $stdout.tty?
+        end
+
+        def require_desktop_gems!
+          require 'dbus'
+        rescue LoadError
+          warn Rainbow(::I18n.t('rosett_ai.cli.dbus.missing_dependency',
+                                default: 'Desktop features require the ruby-dbus gem. ' \
+                                         'Install with: apt install rosett-ai-gtk4')).red
+          exit EXIT_MISSING_DEPENDENCY
+        end
+
+        def check_dbus_availability
+          return if RosettAi::DBus::Service.dbus_available?
+
+          warn Rainbow(t('bus_unavailable')).red
+          warn t('bus_unavailable_hint')
+          exit EXIT_DBUS_FAILURE
+        end
+
+        def service_running?
+          bus = ::DBus::SessionBus.instance
+          bus.service(RosettAi::DBus::Service::BUS_NAME).exists?
+        rescue ::DBus::Error
+          false
+        end
+
+        def print_not_running
+          if tty_output?
+            warn Rainbow(t('not_running')).yellow
+            warn t('start_hint', command: 'bin/raictl dbus start')
+          else
+            puts JSON.generate(running: false)
+          end
+        end
+
+        # -- TTY vs JSON branching
+        def print_running_status
+          status_data = fetch_service_status
+          return unless status_data
+
+          if tty_output?
+            print_status_table(status_data)
+          else
+            puts JSON.generate(status_data)
+          end
+        end
+
+        def fetch_service_status
+          bus = ::DBus::SessionBus.instance
+          service = bus.service(RosettAi::DBus::Service::BUS_NAME)
+          object = service.object(RosettAi::DBus::Service::OBJECT_PATH)
+          object.introspect
+          object.default_iface = 'be.neatnerds.rosettai.Manager'
+          object.GetStatus.first
+        rescue ::DBus::Error => e
+          warn Rainbow(t('error_querying', message: e.message)).red
+          nil
+        end
+
+        def print_status_table(status_data)
+          puts Rainbow(t('status_title')).bright
+          puts
+
+          rows = status_data.map { |k, v| [k, v.to_s] }
+          table = ::Terminal::Table.new(
+            headings: [t('property'), t('value')],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def stop_via_dbus
+          bus = ::DBus::SessionBus.instance
+          service = bus.service(RosettAi::DBus::Service::BUS_NAME)
+          object = service.object(RosettAi::DBus::Service::OBJECT_PATH)
+          object.introspect
+          object.default_iface = 'be.neatnerds.rosettai.Manager'
+          object.Shutdown
+        rescue ::DBus::Error => e
+          warn Rainbow("Error stopping service: #{e.message}").red
+          exit EXIT_DBUS_FAILURE
+        end
+
+        def start_foreground
+          warn Rainbow(t('starting')).cyan
+          warn t('press_ctrl_c')
+          $stderr.puts
+
+          service = RosettAi::DBus::Service.new
+          unless service.start
+            warn Rainbow(t('start_failed')).red
+            exit EXIT_DBUS_FAILURE
+          end
+
+          service.run
+        end
+
+        def start_daemon
+          pid = fork do
+            Process.daemon(true, false)
+            service = RosettAi::DBus::Service.new
+            service.start && service.run
+          end
+          Process.detach(pid)
+          warn Rainbow(t('started_background', pid: pid)).green
+        end
+
+        def adapter_for(compositor)
+          ADAPTER_MAP.fetch(compositor, nil)
+        end
+
+        def print_detect_tty(compositor)
+          adapter_name = adapter_for(compositor)
+
+          puts Rainbow(t('detect_title')).bright
+          puts
+          puts "  #{t('detected')}: #{Rainbow(compositor.to_s).cyan}"
+          puts "  #{t('adapter')}:  #{adapter_name ? Rainbow(adapter_name).green : Rainbow(t('adapter_none')).yellow}"
+          puts
+
+          print_environment_table
+        end
+
+        def print_detect_json(compositor)
+          env_data = ENV_VARS.to_h do |var|
+            [var, ENV.fetch(var, nil)]
+          end
+
+          puts JSON.generate(
+            compositor: compositor.to_s,
+            adapter: adapter_for(compositor),
+            environment: env_data
+          )
+        end
+
+        def print_environment_table
+          rows = ENV_VARS.map do |var|
+            value = ENV.fetch(var, nil)
+            [var, value ? Rainbow(value).cyan : Rainbow(t('not_set')).faint]
+          end
+
+          puts Rainbow(t('env_title')).bright
+          puts
+          table = ::Terminal::Table.new(
+            headings: [t('variable'), t('value')],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'thor'
+require 'rainbow'
+require 'terminal-table'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor tasks for design document management
+      class Design < ::Thor
+        desc 'validate [NAME]', 'Validate design document(s) against the design schema'
+        long_desc <<~LONGDESC
+          Validates design document(s) against JSON schema. If NAME is provided, validates
+          only that document; otherwise validates all design documents.
+
+          Exit codes: 1 if any validation fails
+
+          EXAMPLES
+
+            raictl design validate
+            raictl design validate architecture
+
+          Related commands: raictl design list, rai design show
+        LONGDESC
+        def validate(name = nil)
+          name = RosettAi::TextSanitizer.normalize_nfc(name) if name
+          files = files_to_validate(name)
+          return puts Rainbow(t('no_documents')).yellow if files.empty?
+
+          all_valid = validate_files(files)
+          raise ::Thor::Error, t('validation_failed') unless all_valid
+        end
+
+        desc 'show NAME', 'Display a design document summary'
+        long_desc <<~LONGDESC
+          Displays formatted design document with metadata, intent, constraints, and acceptance criteria.
+          By default shows essential sections only. Use --full to include examples and preferences.
+
+          Flags:
+            --full: Show all sections including examples, anti-patterns, and preferences
+
+          EXAMPLES
+
+            raictl design show architecture
+            raictl design show security --full
+
+          Related commands: raictl design list, rai design validate
+        LONGDESC
+        method_option :full, type: :boolean, default: false,
+                             desc: 'Show all sections including examples and preferences'
+
+        def show(name)
+          name = RosettAi::TextSanitizer.normalize_nfc(name)
+          file_path = find_design_file(name)
+          raise ::Thor::Error, Rainbow(t('not_found', name: name)).red unless file_path
+
+          data = RosettAi::YamlLoader.load_file(file_path)
+          raise ::Thor::Error, Rainbow(t('empty_file', path: file_path)).red if data.nil?
+
+          sanitized = RosettAi::TextSanitizer.sanitize_for_display(data)
+
+          print_design_header(sanitized)
+          print_section(t('intent'), sanitized['intent'])
+          print_numbered_section(t('constraints'), sanitized['constraints'])
+          print_numbered_section(t('acceptance_criteria'), sanitized['acceptance_criteria'])
+          print_dependencies(sanitized['depends_on'])
+
+          return unless options[:full]
+
+          print_examples(sanitized['examples'])
+          print_numbered_section(t('anti_patterns'), sanitized['anti_patterns'])
+          print_preferences(sanitized['preferences'])
+        end
+
+        desc 'list', 'List all design documents'
+        long_desc <<~LONGDESC
+          Lists all design documents in a table with name, version, status, domain, and priority.
+          Results are sorted by priority then name.
+
+          EXAMPLES
+
+            raictl design list
+
+          Related commands: raictl design show, rai design validate
+        LONGDESC
+        def list
+          files = design_files
+          if files.empty?
+            puts Rainbow(t('no_documents_found')).yellow
+            return
+          end
+
+          print_design_list(files)
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.design.#{key}", **)
+        end
+
+        def design_path
+          RosettAi.conf_root.join('conf', 'design')
+        end
+
+        def design_files
+          Dir.glob(design_path.join('*.yml'))
+        end
+
+        def find_design_file(name)
+          path = design_path.join("#{name}.yml")
+          path.exist? ? path.to_s : nil
+        end
+
+        def files_to_validate(name)
+          return design_files unless name
+
+          file = find_design_file(name)
+          unless file
+            puts Rainbow(t('not_found', name: name)).red
+            return []
+          end
+          [file]
+        end
+
+        def validate_files(files)
+          validator = RosettAi::Validators::DesignValidator.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 print_design_header(data)
+          rows = [
+            [t('name'), data['name']],
+            [t('design_version'), data['version']],
+            [t('status'),     format_status(data['status'])],
+            [t('domain'),     data['domain']],
+            [t('priority'),   data['priority']],
+            ['Author',     data['author']],
+            ['Created',    data['created_at']],
+            ['Modified',   data['modified_at']],
+            ['Modified By', data['modified_by']]
+          ]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(data['name'] || 'Design Document').bright,
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+          puts
+        end
+
+        def print_section(title, content)
+          return unless content
+
+          puts Rainbow(title).bright.underline
+          puts content.to_s.strip
+          puts
+        end
+
+        def print_numbered_section(title, items)
+          return unless items.is_a?(Array) && !items.empty?
+
+          puts Rainbow(title).bright.underline
+          items.each_with_index do |item, index|
+            puts "  #{index + 1}. #{item}"
+          end
+          puts
+        end
+
+        def print_dependencies(deps)
+          return unless deps.is_a?(Array) && !deps.empty?
+
+          puts Rainbow(t('dependencies')).bright.underline
+          deps.each { |dep| puts "  - #{dep}" }
+          puts
+        end
+
+        def print_examples(examples)
+          return unless examples.is_a?(Array) && !examples.empty?
+
+          puts Rainbow(t('examples')).bright.underline
+          examples.each do |example|
+            puts "  #{Rainbow(t('scenario')).cyan} #{example['scenario']}"
+            puts "  #{Rainbow(t('expected')).green} #{example['expected']&.strip}"
+            puts "  #{Rainbow(t('not_expected')).red} #{example['not']&.strip}" if example['not']
+            puts
+          end
+        end
+
+        def print_preferences(prefs)
+          return unless prefs.is_a?(Hash) && !prefs.empty?
+
+          puts Rainbow(t('preferences')).bright.underline
+          prefs.each do |key, value|
+            formatted = value.is_a?(Array) ? value.join(', ') : value.to_s
+            puts "  #{key}: #{formatted}"
+          end
+          puts
+        end
+
+        def print_design_list(files)
+          rows = files.map { |file| build_design_list_row(file) }
+          rows.sort_by! { |row| [row[4].to_i, row[0].to_s] }
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('title')).bright,
+            headings: [t('name'), t('design_version'), t('status'), t('domain'), t('priority')],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def build_design_list_row(file)
+          data = RosettAi::YamlLoader.load_file(file)
+          [
+            data['name'],
+            data['version'],
+            format_status(data['status']),
+            data['domain'],
+            data['priority']
+          ]
+        rescue StandardError
+          [File.basename(file, '.yml'), '-', Rainbow('error').red, '-', '-']
+        end
+
+        def format_status(status)
+          case status
+          when 'approved' then Rainbow(status).green
+          when 'draft'    then Rainbow(status).yellow
+          else status.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'json'
+require 'thor'
+require 'rainbow'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor task for launching desktop applications.
+      #
+      # @author hugo
+      # @author claude
+      class Desktop < ::Thor
+        desc 'gtk4', 'Launch the GTK4/Adwaita desktop application'
+        long_desc <<~LONGDESC
+          Launches the GTK4/Adwaita desktop GUI for Rosett-AI. Requires rosett-ai-gtk4 package.
+
+          Exit codes:
+            0: success
+            1: GTK4 not available or missing dependencies
+
+          EXAMPLES
+
+            raictl desktop gtk4
+
+          Related commands: raictl desktop status, rai dbus start
+        LONGDESC
+        def gtk4
+          require_desktop_gems!
+          unless RosettAi::Desktop::Gtk4App.available?
+            msg = "#{t('unavailable')}\n#{t('install_adwaita')}\n#{t('install_pkg')}"
+            raise ::Thor::Error, msg
+          end
+
+          app = RosettAi::Desktop::Gtk4App.new
+          exit_code = app.run(ARGV)
+          exit exit_code
+        end
+
+        desc 'status', 'Show desktop integration status'
+        long_desc <<~LONGDESC
+          Shows availability status of GTK4 application and D-Bus service.
+          Output format depends on TTY detection (table or JSON).
+
+          EXAMPLES
+
+            raictl desktop status
+
+          Related commands: raictl desktop gtk4, rai dbus status
+        LONGDESC
+        def status
+          require_desktop_gems!
+          gtk4_available = RosettAi::Desktop::Gtk4App.available?
+          dbus_running = check_dbus_service
+
+          if tty_output?
+            print_status_tty(gtk4_available, dbus_running)
+          else
+            print_status_json(gtk4_available, dbus_running)
+          end
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.desktop.#{key}", **)
+        end
+
+        def tty_output?
+          $stdout.tty?
+        end
+
+        def require_desktop_gems!
+          require 'dbus'
+        rescue LoadError
+          raise ::Thor::Error, ::I18n.t('rosett_ai.cli.dbus.missing_dependency',
+                                        default: 'Desktop features require the ruby-dbus gem. ' \
+                                                 'Install with: apt install rosett-ai-gtk4')
+        end
+
+        def check_dbus_service
+          client = RosettAi::Desktop::DbusClient.new
+          client.service_available?
+        rescue StandardError
+          false
+        end
+
+        # -- user-facing display logic
+        def print_status_tty(gtk4_available, dbus_running)
+          puts Rainbow(t('status_title')).bright
+          puts
+
+          gtk4_label = gtk4_available ? t('available') : t('not_installed')
+          gtk4_color = gtk4_available ? :green : :yellow
+          puts "  #{t('gtk4_label')}: #{Rainbow(gtk4_label).color(gtk4_color)}"
+
+          dbus_label = dbus_running ? t('running') : t('not_running')
+          dbus_color = dbus_running ? :green : :yellow
+          puts "  #{t('dbus_label')}: #{Rainbow(dbus_label).color(dbus_color)}"
+          puts
+
+          unless gtk4_available
+            puts Rainbow(t('to_enable_gtk4')).cyan
+            puts "  #{t('install_adwaita')}"
+            puts "  #{t('install_pkg')}"
+            puts
+          end
+
+          return if dbus_running
+
+          puts Rainbow(t('to_start_dbus')).cyan
+          puts '  bin/raictl dbus start'
+          puts
+        end
+
+        def print_status_json(gtk4_available, dbus_running)
+          puts JSON.generate(
+            gtk4: { available: gtk4_available },
+            dbus: { running: dbus_running }
+          )
+        end
+      end
+    end
+  end
+end