rosett-ai 1.3.3

data/lib/rosett_ai/dbus/status_notifier_interface.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'dbus'
+
+module RosettAi
+  module DBus
+    # D-Bus StatusNotifierItem interface for system tray presence.
+    #
+    # Implements org.kde.StatusNotifierItem, the freedesktop standard
+    # for system tray icons on Linux. Supports KDE, GNOME (via extension),
+    # and Xfce status notifier hosts.
+    #
+    # Degrades gracefully if no StatusNotifierHost is available.
+    class StatusNotifierInterface < ::DBus::Object
+      INTERFACE = 'org.kde.StatusNotifierItem'
+
+      CATEGORY = 'ApplicationStatus'
+      ICON_NAME = 'rosett-ai-symbolic'
+      APP_ID = 'be.neatnerds.rosettai'
+
+      dbus_interface INTERFACE do
+        dbus_method :Activate, 'in x:i, in y:i' do |_x, _y|
+          activate
+        end
+
+        dbus_method :ContextMenu, 'in x:i, in y:i' do |_x, _y|
+          context_menu
+        end
+
+        dbus_attr_reader :id, 's'
+        dbus_attr_reader :category, 's'
+        dbus_attr_reader :status, 's'
+        dbus_attr_reader :title, 's'
+        dbus_attr_reader :icon_name, 's'
+        dbus_attr_reader :tool_tip, '(sa(iiay)ss)'
+
+        dbus_signal :NewStatus, 'status:s'
+        dbus_signal :NewTitle
+      end
+
+      def initialize(path)
+        super
+        @current_status = 'Active'
+      end
+
+      def id         = APP_ID
+      def category   = CATEGORY
+      def status     = @current_status
+      def title      = "rai #{RosettAi::VERSION}"
+      def icon_name  = ICON_NAME
+
+      # ToolTip is a struct: (icon_name, icon_pixmap[], title, body)
+      def tool_tip
+        [ICON_NAME, [], "rai #{RosettAi::VERSION}", 'NeatNerds Code Companion']
+      end
+
+      # Update displayed status and emit signal.
+      #
+      # @param new_status [String] one of 'Passive', 'Active', 'NeedsAttention'
+      def update_status(new_status)
+        @current_status = new_status
+        NewStatus(new_status)
+      end
+
+      private
+
+      def activate
+        RosettAi.logger.info('StatusNotifierItem activated')
+      end
+
+      def context_menu
+        RosettAi.logger.info('StatusNotifierItem context menu requested')
+      end
+    end
+  end
+end

data/lib/rosett_ai/deprecation.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'rainbow'
+
+module RosettAi
+  # Structured deprecation warning system.
+  #
+  # Emits formatted warnings to stderr when deprecated features are used,
+  # including the version where deprecation started and the planned removal
+  # version. Warnings are deduplicated per session to avoid noise.
+  #
+  # @author hugo
+  # @author claude
+  # @see conf/design/backward_compatibility.yml
+  module Deprecation
+    @warned = {}
+    @mutex = Mutex.new
+
+    class << self
+      # Emit a deprecation warning for a feature.
+      #
+      # Deduplicates by feature name — a second call for the same feature
+      # within the same process is silently ignored.
+      #
+      # @param feature [String] the deprecated feature name (e.g. "--target")
+      # @param replacement [String] the replacement (e.g. "--engine")
+      # @param since [String] version when deprecation started (e.g. "1.1.0")
+      # @param removal [String] version when feature will be removed (e.g. "2.0.0")
+      # @param stderr [IO] output stream for warnings (default: $stderr)
+      # @return [void]
+      def warn_deprecated(feature:, replacement:, since:, removal:, stderr: $stderr)
+        return if already_warned?(feature)
+
+        mark_warned(feature)
+        message = format_message(feature: feature, replacement: replacement, since: since, removal: removal)
+        formatted = tty?(stderr) ? Rainbow(message).yellow : message
+        stderr.puts formatted
+      end
+
+      # Check whether a feature has already been warned in this session.
+      #
+      # @param feature [String]
+      # @return [Boolean]
+      def already_warned?(feature)
+        @mutex.synchronize { @warned.key?(feature) }
+      end
+
+      # Reset all warned state. Intended for test isolation.
+      #
+      # @return [void]
+      def reset!
+        @mutex.synchronize { @warned = {} }
+      end
+
+      private
+
+      def mark_warned(feature)
+        @mutex.synchronize { @warned[feature] = true }
+      end
+
+      def format_message(feature:, replacement:, since:, removal:)
+        ::I18n.t(
+          'rosett_ai.deprecation.warning',
+          feature: feature,
+          replacement: replacement,
+          since: since,
+          removal: removal
+        )
+      end
+
+      def tty?(io)
+        io.respond_to?(:tty?) && io.tty?
+      end
+    end
+  end
+end

data/lib/rosett_ai/desktop/dbus_client.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'dbus'
+require_relative 'gui_logger'
+
+module RosettAi
+  module Desktop
+    # D-Bus client for communicating with be.neatnerds.rosettai service.
+    #
+    # SAFETY: This client is designed to NEVER raise exceptions to callers.
+    # All methods return safe default values on failure. This is critical
+    # for GUI stability - a D-Bus failure should never crash the app.
+    #
+    # All GTK4/Qt6 desktop apps use this client instead of calling
+    # Ruby Rosett-AI modules directly. This ensures the D-Bus service is
+    # the single source of truth.
+    class DbusClient
+      BUS_NAME = 'be.neatnerds.rosettai'
+      OBJECT_PATH = '/be/neatnerds/rosett-ai'
+      MANAGER_IFACE = 'be.neatnerds.rosettai.Manager'
+      FOCUS_IFACE = 'be.neatnerds.rosettai.FocusMonitor'
+
+      # Default safe return values
+      SAFE_STATUS = { 'error' => 'Service not available', 'version' => 'unknown' }.freeze
+      SAFE_FOCUS = ['', ''].freeze
+      SAFE_COMPILE_RESULT = 'Error: D-Bus service not available'
+
+      attr_reader :bus, :last_error
+
+      def initialize
+        @bus = nil
+        @object = nil
+        @connected = false
+        @last_error = nil
+      end
+
+      # Connect to the D-Bus session bus and get service proxy.
+      #
+      # @return [Boolean] true if connected successfully
+      def connect
+        return true if @connected
+
+        GuiLogger.dbus_call(:connect, bus_name: BUS_NAME)
+        @last_error = nil
+        @bus = ::DBus::SessionBus.instance
+        service = @bus.service(BUS_NAME)
+        @object = service.object(OBJECT_PATH)
+        @object.introspect
+        @connected = true
+        GuiLogger.dbus_call(:connect, status: :success)
+        true
+      rescue ::DBus::Error => e
+        @last_error = e.message
+        log_error('D-Bus connection failed', e)
+        @connected = false
+        false
+      rescue StandardError => e
+        @last_error = e.message
+        log_error('Unexpected error during D-Bus connection', e)
+        @connected = false
+        false
+      end
+
+      # Check if connected to D-Bus service.
+      #
+      # @return [Boolean]
+      def connected?
+        @connected
+      end
+
+      # Check if the D-Bus service is available.
+      # SAFETY: Never raises, returns false on any error.
+      #
+      # @return [Boolean]
+      def service_available?
+        return false unless connect
+
+        @bus.service(BUS_NAME).exists?
+      rescue StandardError => e
+        log_error('Service availability check failed', e)
+        false
+      end
+
+      # Get service status from Manager interface.
+      # SAFETY: Never raises, returns safe default hash on error.
+      #
+      # @return [Hash] status dictionary
+      def status
+        return SAFE_STATUS.dup unless safe_connect
+
+        @object.default_iface = MANAGER_IFACE
+        result = @object.GetStatus
+        result.is_a?(Array) ? result.first : SAFE_STATUS.dup
+      rescue StandardError => e
+        log_error('GetStatus failed', e)
+        SAFE_STATUS.merge('error' => e.message)
+      end
+
+      # Run compilation via D-Bus.
+      # SAFETY: Never raises, returns error string on failure.
+      #
+      # @return [String] compilation result or error message
+      def compile
+        GuiLogger.dbus_call(:compile, interface: MANAGER_IFACE)
+        return SAFE_COMPILE_RESULT unless safe_connect
+
+        @object.default_iface = MANAGER_IFACE
+        result = @object.Compile
+        output = result.is_a?(Array) ? result.first : result.to_s
+        GuiLogger.dbus_call(:compile, status: :success, result_length: output.length)
+        output
+      rescue StandardError => e
+        log_error('Compile failed', e)
+        "Error: #{e.message}"
+      end
+
+      # Switch AI context.
+      # SAFETY: Never raises, returns false on failure.
+      #
+      # @param context_name [String] name of context to switch to
+      # @return [Boolean] true if successful
+      def switch_context(context_name)
+        return false unless safe_connect
+
+        @object.default_iface = MANAGER_IFACE
+        @object.SwitchContext(context_name)
+        true
+      rescue StandardError => e
+        log_error('SwitchContext failed', e)
+        false
+      end
+
+      # Get current focus from FocusMonitor interface.
+      # SAFETY: Never raises, returns empty array on failure.
+      #
+      # @return [Array<String>] [app_id, window_title]
+      def current_focus
+        return SAFE_FOCUS.dup unless safe_connect
+
+        @object.default_iface = FOCUS_IFACE
+        result = @object.GetCurrentFocus
+        result.is_a?(Array) && result.size >= 2 ? result : SAFE_FOCUS.dup
+      rescue StandardError => e
+        log_error('GetCurrentFocus failed', e)
+        SAFE_FOCUS.dup
+      end
+
+      # Subscribe to FocusChanged signal.
+      # SAFETY: Never raises, silently fails if service unavailable.
+      #
+      # @yield [app_id, title] called when focus changes
+      # @return [Boolean] true if subscription succeeded
+      def on_focus_changed(&block)
+        return false unless safe_connect
+        return false unless block
+
+        @object.default_iface = FOCUS_IFACE
+        @object.on_signal('FocusChanged', &block)
+        true
+      rescue StandardError => e
+        log_error('FocusChanged subscription failed', e)
+        false
+      end
+
+      # Subscribe to ContextChanged signal.
+      # SAFETY: Never raises, silently fails if service unavailable.
+      #
+      # @yield [context_name] called when context changes
+      # @return [Boolean] true if subscription succeeded
+      def on_context_changed(&block)
+        return false unless safe_connect
+        return false unless block
+
+        @object.default_iface = MANAGER_IFACE
+        @object.on_signal('ContextChanged', &block)
+        true
+      rescue StandardError => e
+        log_error('ContextChanged subscription failed', e)
+        false
+      end
+
+      # List available engines from D-Bus service.
+      # SAFETY: Never raises, returns empty array on failure.
+      #
+      # @return [Array<Hash>] engine hashes with :name and :display_name keys
+      def list_engines
+        return [] unless safe_connect
+
+        @object.default_iface = MANAGER_IFACE
+        result = @object.ListEngines
+        tuples = result.is_a?(Array) ? result.first : []
+        (tuples || []).map { |name, display| { name: name, display_name: display } }
+      rescue StandardError => e
+        log_error('ListEngines failed', e)
+        []
+      end
+
+      # Update a configuration key via D-Bus.
+      # SAFETY: Never raises, returns false on failure.
+      #
+      # @param key [String] configuration key (e.g. 'default_engine')
+      # @param value [String] new value
+      # @return [Boolean] true if successful
+      def set_config(key, value)
+        return false unless safe_connect
+
+        @object.default_iface = MANAGER_IFACE
+        result = @object.SetConfig(key, value.to_s)
+        output = result.is_a?(Array) ? result.first : result.to_s
+        !output.start_with?('Error:')
+      rescue StandardError => e
+        log_error('SetConfig failed', e)
+        false
+      end
+
+      # Disconnect from D-Bus.
+      # SAFETY: Never raises.
+      def disconnect
+        @connected = false
+        @object = nil
+        @bus = nil
+        @last_error = nil
+      rescue StandardError => e
+        log_error('Disconnect failed', e)
+      end
+
+      private
+
+      # Safe connect that never raises.
+      #
+      # @return [Boolean] true if connected
+      def safe_connect
+        connect
+      rescue StandardError => e
+        log_error('Safe connect failed', e)
+        false
+      end
+
+      # Log error without raising.
+      #
+      # @param context [String] what operation failed
+      # @param error [Exception] the error
+      def log_error(context, error)
+        @last_error = error.message
+        GuiLogger.error(context, error, component: 'DbusClient')
+
+        return unless defined?(RosettAi.logger) && RosettAi.logger
+
+        RosettAi.logger.debug("[DbusClient] #{context}: #{error.class} - #{error.message}")
+      rescue StandardError
+        # Never let logging itself cause issues
+        nil
+      end
+    end
+  end
+end