rosett-ai 1.3.3

data/lib/rosett_ai/dbus/compositor_detector.rb

@@ -0,0 +1,77 @@
+# 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
+    # Detects the current compositor/window manager.
+    #
+    # Detection order (first match wins):
+    # 1. HYPRLAND_INSTANCE_SIGNATURE env var → :hyprland
+    # 2. SWAYSOCK env var → :sway
+    # 3. I3SOCK env var → :i3
+    # 4. org.gnome.Shell D-Bus name active → :gnome
+    # 5. org.kde.KWin D-Bus name active → :kwin
+    # 6. DISPLAY set, WAYLAND_DISPLAY unset → :x11
+    # 7. else → :unknown
+    module CompositorDetector
+      COMPOSITOR_CHECKS = [
+        { env: 'HYPRLAND_INSTANCE_SIGNATURE', type: :hyprland },
+        { env: 'SWAYSOCK', type: :sway },
+        { env: 'I3SOCK', type: :i3 }
+      ].freeze
+
+      DBUS_NAMES = {
+        'org.gnome.Shell' => :gnome,
+        'org.kde.KWin' => :kwin
+      }.freeze
+
+      class << self
+        # Detect the current compositor
+        #
+        # @return [Symbol] Compositor type
+        def detect
+          # Check environment variables first
+          COMPOSITOR_CHECKS.each do |check|
+            return check[:type] if ENV.key?(check[:env])
+          end
+
+          # Check D-Bus names
+          compositor = detect_via_dbus
+          return compositor if compositor
+
+          # Check for X11
+          return :x11 if x11_only?
+
+          :unknown
+        end
+
+        private
+
+        def detect_via_dbus
+          bus = ::DBus::SessionBus.instance
+          proxy = bus.service('org.freedesktop.DBus').object('/org/freedesktop/DBus')
+          proxy.introspect
+          proxy.default_iface = 'org.freedesktop.DBus'
+
+          names = proxy.ListNames.first
+
+          DBUS_NAMES.each do |name, type|
+            return type if names.include?(name)
+          end
+
+          nil
+        rescue ::DBus::Error
+          nil
+        end
+
+        def x11_only?
+          ENV.key?('DISPLAY') && !ENV.key?('WAYLAND_DISPLAY')
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/focus_adapters/base.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module DBus
+    module FocusAdapters
+      # Base class for compositor-specific focus adapters.
+      #
+      # Each adapter implements the same interface:
+      # - #start: Begin monitoring focus changes
+      # - #stop: Stop monitoring
+      # - #on_focus_change(&block): Register callback for focus changes
+      #
+      # Callbacks receive (app_id, title) arguments.
+      class Base
+        def initialize
+          @callbacks = []
+          @running = false
+        end
+
+        # Register callback for focus changes
+        #
+        # @yield [app_id, title] Called on focus change
+        def on_focus_change(&block)
+          @callbacks << block
+        end
+
+        # Start monitoring focus changes
+        def start
+          raise NotImplementedError, "#{self.class}#start must be implemented"
+        end
+
+        # Stop monitoring
+        def stop
+          @running = false
+        end
+
+        # Check if monitoring is active
+        #
+        # @return [Boolean]
+        def running?
+          @running
+        end
+
+        protected
+
+        # Notify all registered callbacks of a focus change
+        #
+        # @param app_id [String] Application identifier
+        # @param title [String] Window title
+        def notify_focus_change(app_id, title)
+          @callbacks.each { |cb| cb.call(app_id.to_s, title.to_s) }
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/focus_adapters/gnome_adapter.rb

@@ -0,0 +1,172 @@
+# 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
+    module FocusAdapters
+      # Focus adapter for GNOME Shell.
+      #
+      # Uses GNOME Shell's D-Bus interface to query the focused window.
+      # For GNOME < 41, uses org.gnome.Shell.Eval (JavaScript evaluation).
+      # For GNOME >= 41, Eval is removed; falls back to xdotool + xprop.
+      class GnomeAdapter < Base
+        POLL_INTERVAL = 0.5 # seconds
+        GNOME_EVAL_REMOVED_VERSION = 41
+
+        def initialize
+          super
+          @bus = nil
+          @thread = nil
+          @last_app_id = nil
+          @last_title = nil
+          @use_xdotool = false
+        end
+
+        def start
+          return if @running
+
+          @bus = ::DBus::SessionBus.instance
+          configure_focus_method
+          @running = true
+          @thread = Thread.new { run_poll_loop }
+        rescue ::DBus::Error => e
+          RosettAi.logger.error("Failed to connect to D-Bus: #{e.message}")
+          @running = false
+        end
+
+        def stop
+          super
+          @thread&.kill
+          @bus = nil
+        end
+
+        private
+
+        # Select the focus detection strategy based on GNOME version.
+        def configure_focus_method
+          version = detect_gnome_version
+          @use_xdotool = version.to_i >= GNOME_EVAL_REMOVED_VERSION
+          return unless @use_xdotool
+
+          RosettAi.logger.warn(
+            "GNOME #{version} detected; org.gnome.Shell.Eval is unavailable. " \
+            'Falling back to xdotool for focus detection.'
+          )
+        end
+
+        def run_poll_loop
+          while @running
+            poll_focused_window
+            sleep POLL_INTERVAL
+          end
+        rescue StandardError => e
+          RosettAi.logger.error("GNOME focus poll error: #{e.message}")
+          @running = false
+        end
+
+        def poll_focused_window
+          if @use_xdotool
+            poll_focused_window_xdotool
+          else
+            poll_focused_window_eval
+          end
+        end
+
+        def poll_focused_window_eval
+          result = eval_shell_js('global.display.focus_window ? global.display.focus_window.get_wm_class() : ""')
+          app_id = result || ''
+
+          title_result = eval_shell_js('global.display.focus_window ? global.display.focus_window.get_title() : ""')
+          title = title_result || ''
+
+          return if app_id == @last_app_id && title == @last_title
+
+          @last_app_id = app_id
+          @last_title = title
+          notify_focus_change(app_id, title)
+        end
+
+        def poll_focused_window_xdotool
+          app_id = poll_active_window_xdotool
+          title = app_id ? (poll_active_window_title_xdotool || '') : return
+
+          return if app_id == @last_app_id && title == @last_title
+
+          @last_app_id = app_id
+          @last_title = title
+          notify_focus_change(app_id, title)
+        end
+
+        # Detect GNOME Shell version via the ShellVersion D-Bus property.
+        #
+        # @return [Integer] Major version number, or 0 if detection fails
+        def detect_gnome_version
+          shell_object = fetch_shell_object
+          shell_object['org.gnome.Shell']['ShellVersion'].to_s.split('.').first.to_i
+        rescue ::DBus::Error
+          0
+        end
+
+        # Query the active window WM_CLASS via xdotool and xprop.
+        #
+        # @return [String, nil] The WM_CLASS instance name, or nil
+        def poll_active_window_xdotool
+          window_id = IO.popen(['xdotool', 'getactivewindow'], err: File::NULL, &:read).strip
+          return if window_id.empty?
+
+          extract_wm_class(window_id)
+        rescue Errno::ENOENT
+          handle_missing_xdotool
+        end
+
+        # Extract WM_CLASS from xprop output for a given window ID.
+        def extract_wm_class(window_id)
+          output = IO.popen(['xprop', '-id', window_id, 'WM_CLASS'], err: File::NULL, &:read)
+          match = output.match(/WM_CLASS.*=\s*"([^"]+)"/)
+          match ? match[1] : nil
+        end
+
+        # Handle missing xdotool/xprop binary.
+        def handle_missing_xdotool
+          RosettAi.logger.warn(
+            'xdotool or xprop not found. Install xdotool for focus detection on GNOME 41+: ' \
+            'sudo apt install xdotool'
+          )
+          @use_xdotool = false
+          nil
+        end
+
+        # Query the active window title via xdotool.
+        #
+        # @return [String, nil] The window title, or nil
+        def poll_active_window_title_xdotool
+          IO.popen(['xdotool', 'getactivewindow', 'getwindowname'], err: File::NULL, &:read).strip
+        rescue Errno::ENOENT
+          nil
+        end
+
+        # Fetch the GNOME Shell D-Bus object.
+        def fetch_shell_object
+          service = @bus.service('org.gnome.Shell')
+          object = service.object('/org/gnome/Shell')
+          object.introspect
+          object
+        end
+
+        def eval_shell_js(code)
+          object = fetch_shell_object
+          object.default_iface = 'org.gnome.Shell'
+
+          success, result = object.Eval(code)
+          success ? result.gsub(/^"|"$/, '') : nil
+        rescue ::DBus::Error
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/focus_adapters/hyprland_adapter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module DBus
+    module FocusAdapters
+      # Focus adapter for Hyprland compositor.
+      #
+      # Uses Hyprland's IPC socket2 to receive activewindow events.
+      # Socket path: $XDG_RUNTIME_DIR/hypr/$HYPRLAND_INSTANCE_SIGNATURE/.socket2.sock
+      class HyprlandAdapter < Base
+        def initialize
+          super
+          @socket = nil
+          @thread = nil
+        end
+
+        def start
+          return if @running
+
+          socket_path = hyprland_socket_path
+          unless socket_path && File.exist?(socket_path)
+            RosettAi.logger.error('Hyprland socket not found')
+            return
+          end
+
+          @socket = UNIXSocket.new(socket_path)
+          @running = true
+          @thread = Thread.new { run_event_loop }
+        rescue StandardError => e
+          RosettAi.logger.error("Failed to connect to Hyprland: #{e.message}")
+          @running = false
+        end
+
+        def stop
+          super
+          @thread&.kill
+          @socket&.close
+          @socket = nil
+        end
+
+        private
+
+        def hyprland_socket_path
+          instance_sig = ENV.fetch('HYPRLAND_INSTANCE_SIGNATURE', nil)
+          return nil unless instance_sig
+
+          runtime_dir = ENV.fetch('XDG_RUNTIME_DIR', "/run/user/#{Process.uid}")
+          File.join(runtime_dir, 'hypr', instance_sig, '.socket2.sock')
+        end
+
+        def run_event_loop
+          while @running
+            line = @socket.gets
+            break unless line
+
+            handle_event(line.strip)
+          end
+        rescue StandardError => e
+          RosettAi.logger.error("Hyprland event loop error: #{e.message}")
+          @running = false
+        end
+
+        def handle_event(line)
+          # Event format: activewindow>>class,title
+          return unless line.start_with?('activewindow>>')
+
+          data = line.sub('activewindow>>', '')
+          app_id, title = data.split(',', 2)
+          notify_focus_change(app_id || '', title || '')
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/focus_adapters/i3_adapter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module DBus
+    module FocusAdapters
+      # Focus adapter for i3 and sway window managers.
+      #
+      # Uses the i3ipc gem to subscribe to window::focus events
+      # via the i3/sway IPC socket.
+      class I3Adapter < Base
+        def initialize
+          super
+          @connection = nil
+          @thread = nil
+        end
+
+        def start
+          return if @running
+
+          require 'i3ipc'
+          @connection = I3Ipc::Connection.new
+          @running = true
+
+          @thread = Thread.new { run_event_loop }
+        rescue LoadError
+          RosettAi.logger.error('i3ipc gem not available')
+          @running = false
+        rescue StandardError => e
+          RosettAi.logger.error("Failed to connect to i3/sway IPC: #{e.message}")
+          @running = false
+        end
+
+        def stop
+          super
+          @thread&.kill
+          @connection = nil
+        end
+
+        private
+
+        def run_event_loop
+          @connection.subscribe('window') do |event|
+            handle_window_event(event) if event['change'] == 'focus'
+          end
+        rescue StandardError => e
+          RosettAi.logger.error("i3/sway event loop error: #{e.message}")
+          @running = false
+        end
+
+        def handle_window_event(event)
+          container = event['container']
+          return unless container
+
+          app_id = container['app_id'] || container['window_properties']&.fetch('class', '') || ''
+          title = container['name'] || ''
+
+          notify_focus_change(app_id, title)
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/focus_adapters/kwin_adapter.rb

@@ -0,0 +1,103 @@
+# 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
+    module FocusAdapters
+      # Focus adapter for KDE KWin.
+      #
+      # Uses KWin's D-Bus scripting API to monitor focus changes.
+      # Listens for the activeWindowChanged signal from org.kde.KWin.
+      class KwinAdapter < Base
+        def initialize
+          super
+          @bus = nil
+          @main_loop = nil
+          @thread = nil
+        end
+
+        def start
+          return if @running
+
+          @bus = ::DBus::SessionBus.instance
+          @running = true
+          setup_signal_handler
+          @thread = Thread.new { run_event_loop }
+        rescue ::DBus::Error => e
+          RosettAi.logger.error("Failed to connect to KWin D-Bus: #{e.message}")
+          @running = false
+        end
+
+        def stop
+          super
+          @main_loop&.quit
+          @thread&.kill
+          @bus = nil
+        end
+
+        private
+
+        def setup_signal_handler
+          service = @bus.service('org.kde.KWin')
+          object = service.object('/KWin')
+          object.introspect
+
+          object.on_signal('activeWindowChanged') do
+            poll_active_window
+          end
+        rescue ::DBus::Error
+          RosettAi.logger.warn('KWin activeWindowChanged signal not available, falling back to polling')
+          @polling_mode = true
+        end
+
+        def run_event_loop
+          if @polling_mode
+            run_poll_loop
+          else
+            @main_loop = ::DBus::Main.new
+            @main_loop << @bus
+            @main_loop.run
+          end
+        rescue StandardError => e
+          RosettAi.logger.error("KWin event loop error: #{e.message}")
+          @running = false
+        end
+
+        def run_poll_loop
+          while @running
+            poll_active_window
+            sleep 0.5
+          end
+        end
+
+        def poll_active_window
+          service = @bus.service('org.kde.KWin')
+          object = service.object('/KWin')
+          object.introspect
+          object.default_iface = 'org.kde.KWin'
+
+          # KWin API varies by version - try to get active window info
+          # For now, we use a basic polling approach that may need adaptation
+          app_id = ''
+          title = ''
+
+          begin
+            # Try KDE 6 approach first
+            object.default_iface = 'org.kde.KWin.Scripting'
+            # KWin scripting is complex; for now just poll basic info
+          rescue ::DBus::Error
+            # Fall through to notify
+          end
+
+          notify_focus_change(app_id, title)
+        rescue ::DBus::Error
+          # KWin API varies, ignore errors
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/focus_adapters/x11_adapter.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module DBus
+    module FocusAdapters
+      # Focus adapter for X11 window managers.
+      #
+      # Uses xprop to monitor _NET_ACTIVE_WINDOW property changes.
+      # Falls back to polling if xprop spy mode is not available.
+      class X11Adapter < Base
+        POLL_INTERVAL = 0.5 # seconds
+
+        def initialize
+          super
+          @thread = nil
+          @xprop_process = nil
+          @last_window_id = nil
+        end
+
+        def start
+          return if @running
+          return unless xprop_available?
+
+          @running = true
+          @thread = Thread.new { run_poll_loop }
+        end
+
+        def stop
+          super
+          @thread&.kill
+          @xprop_process&.close
+        end
+
+        private
+
+        def xprop_available?
+          system('which xprop > /dev/null 2>&1')
+        end
+
+        def run_poll_loop
+          while @running
+            poll_active_window
+            sleep POLL_INTERVAL
+          end
+        rescue StandardError => e
+          RosettAi.logger.error("X11 focus poll error: #{e.message}")
+          @running = false
+        end
+
+        def poll_active_window
+          win_id = active_window_id
+          return if win_id == @last_window_id
+          return unless win_id
+
+          @last_window_id = win_id
+          app_id, title = window_info(win_id)
+          notify_focus_change(app_id, title)
+        end
+
+        def active_window_id
+          output = IO.popen(['xprop', '-root', '_NET_ACTIVE_WINDOW'], err: File::NULL, &:read)
+          match = output.match(/window id # (0x[0-9a-f]+)/i)
+          match ? match[1] : nil
+        rescue Errno::ENOENT
+          nil
+        end
+
+        def window_info(window_id)
+          return ['', ''] unless window_id
+
+          app_id = extract_wm_class(window_id)
+          title = extract_window_title(window_id)
+
+          [app_id, title]
+        end
+
+        def extract_wm_class(window_id)
+          output = IO.popen(['xprop', '-id', window_id, 'WM_CLASS'], err: File::NULL, &:read)
+          match = output.match(/WM_CLASS\(STRING\) = "([^"]*)", "([^"]*)"/)
+          match ? match[2] : ''
+        rescue Errno::ENOENT
+          ''
+        end
+
+        def extract_window_title(window_id)
+          # Try _NET_WM_NAME first
+          output = IO.popen(['xprop', '-id', window_id, '_NET_WM_NAME'], err: File::NULL, &:read)
+          if (match = output.match(/_NET_WM_NAME\(UTF8_STRING\) = "(.*)"/))
+            return match[1]
+          end
+
+          # Fallback to WM_NAME
+          output = IO.popen(['xprop', '-id', window_id, 'WM_NAME'], err: File::NULL, &:read)
+          match = output.match(/WM_NAME\(.*\) = "(.*)"/)
+          match ? match[1] : ''
+        rescue Errno::ENOENT
+          ''
+        end
+      end
+    end
+  end
+end