rosett-ai 1.3.3

data/lib/rosett_ai/desktop/gtk4_app.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require_relative 'gui_logger'
+
+module RosettAi
+  module Desktop
+    # Main GTK4/Adwaita application for rai desktop integration.
+    #
+    # SAFETY PRINCIPLES:
+    # 1. All event handlers are wrapped with safe_action() - NEVER crash on user action
+    # 2. D-Bus client is defensive - returns safe defaults, never raises
+    # 3. Widget construction is wrapped - missing features degrade gracefully
+    # 4. Error dialogs inform users instead of crashing
+    #
+    # This is a standalone app that communicates with rosett-ai exclusively
+    # via D-Bus. It does NOT import Ruby Rosett-AI modules for business logic.
+    # All operations go through the DbusClient.
+    #
+    # Follows GNOME HIG: single-window, instant-apply preferences,
+    # headerbar with title and buttons.
+    class Gtk4App
+      APPLICATION_ID = 'be.neatnerds.rosettai'
+      UNAVAILABLE_MESSAGE = 'GTK4 app requires the adwaita gem. Install: gem install adwaita'
+
+      attr_reader :application, :dbus_client
+
+      def initialize
+        @dbus_client = DbusClient.new
+        @window = nil
+        @application = nil
+        @toast_overlay = nil
+      end
+
+      # Check if GTK4/Adwaita is available.
+      #
+      # @return [Boolean]
+      def self.available?
+        require 'adwaita'
+        true
+      rescue LoadError
+        false
+      end
+
+      # Run the GTK4 application.
+      # SAFETY: Wrapped in rescue to show error dialog on startup failure.
+      #
+      # @param _argv [Array<String>] command-line arguments (ignored)
+      # @return [Integer] exit code
+      def run(_argv = ARGV)
+        GuiLogger.info('Application starting', version: safe_version)
+        require_adwaita!
+
+        @application = Adw::Application.new(APPLICATION_ID, Gio::ApplicationFlags::FLAGS_NONE)
+        setup_actions
+        @application.signal_connect('activate') { safe_action(:on_activate) }
+        @application.signal_connect('shutdown') { GuiLogger.info('Application shutdown') }
+        GuiLogger.info('Application run loop starting')
+        @application.run([])
+      rescue StandardError => e
+        # Last resort error handling - show dialog if possible, print to stderr
+        show_fatal_error("Application failed to start: #{e.message}")
+        1
+      end
+
+      private
+
+      # Execute a block safely, catching all errors and showing dialog.
+      # This is the core safety mechanism for all GUI event handlers.
+      #
+      # @param action_name [Symbol] name of the action for error reporting
+      # @yield the action to execute
+      def safe_action(action_name)
+        GuiLogger.action(action_name) do
+          send(action_name)
+        end
+      rescue StandardError => e
+        show_error_dialog('An error occurred', "#{action_name}: #{e.message}")
+        log_error("Action #{action_name} failed", e)
+      end
+
+      def require_adwaita!
+        require 'adwaita'
+        # Alias Adwaita to Adw for GNOME SDK naming convention
+        Object.const_set(:Adw, Adwaita) unless Object.const_defined?(:Adw)
+      rescue LoadError
+        raise RosettAi::Error, UNAVAILABLE_MESSAGE
+      end
+
+      def on_activate
+        @window ||= build_main_window
+        @window.present
+      end
+
+      # ========== Window Building ==========
+
+      def build_main_window
+        window = Adw::ApplicationWindow.new(@application)
+        window.title = 'NeatNerds Code Companion'
+        window.set_default_size(600, 450)
+
+        # Main vertical box to hold header + content
+        main_box = Gtk::Box.new(:vertical, 0)
+
+        # Header bar (GNOME HIG style)
+        header = build_header_bar
+        main_box.append(header)
+
+        # Toast overlay for notifications (wraps scrolled content)
+        @toast_overlay = Adw::ToastOverlay.new
+
+        # Scrolled content area
+        scrolled = Gtk::ScrolledWindow.new
+        scrolled.hscrollbar_policy = Gtk::PolicyType::NEVER
+        scrolled.vscrollbar_policy = Gtk::PolicyType::AUTOMATIC
+        scrolled.vexpand = true
+
+        # Clamp for responsive width (GNOME HIG)
+        clamp = Adw::Clamp.new
+        clamp.maximum_size = 600
+        clamp.tightening_threshold = 400
+
+        content = build_main_content
+        clamp.child = content
+        scrolled.child = clamp
+
+        @toast_overlay.child = scrolled
+        main_box.append(@toast_overlay)
+
+        window.content = main_box
+        window
+      end
+
+      def build_header_bar
+        header = Adw::HeaderBar.new
+        header.title_widget = build_title_widget
+
+        # Primary menu button (hamburger) on the right
+        menu_button = Gtk::MenuButton.new
+        menu_button.icon_name = 'open-menu-symbolic'
+        menu_button.menu_model = build_app_menu
+        # primary= may not exist in older GTK4 versions
+        menu_button.primary = true if menu_button.respond_to?(:primary=)
+        header.pack_end(menu_button)
+
+        header
+      end
+
+      def build_title_widget
+        Adw::WindowTitle.new('NeatNerds Code Companion', '')
+      end
+
+      def build_main_content
+        box = Gtk::Box.new(:vertical, 12)
+        box.margin_start = 24
+        box.margin_end = 24
+        box.margin_top = 24
+        box.margin_bottom = 24
+
+        # Status group
+        status_group = build_status_group
+        box.append(status_group)
+
+        # Actions group
+        actions_group = build_actions_group
+        box.append(actions_group)
+
+        box
+      end
+
+      def build_status_group
+        group = Adw::PreferencesGroup.new
+        group.title = 'Service Status'
+
+        # D-Bus connection status
+        dbus_row = Adw::ActionRow.new
+        dbus_row.title = 'D-Bus Service'
+        dbus_row.subtitle = dbus_status_text
+        group.add(dbus_row)
+
+        # Current context row
+        context_row = Adw::ActionRow.new
+        context_row.title = 'Current Context'
+        context_row.subtitle = current_context_text
+        group.add(context_row)
+
+        # Current focus row
+        focus_row = Adw::ActionRow.new
+        focus_row.title = 'Active Application'
+        focus_row.subtitle = current_focus_text
+        group.add(focus_row)
+
+        group
+      end
+
+      def build_actions_group
+        group = Adw::PreferencesGroup.new
+        group.title = 'Quick Actions'
+
+        # Compile button
+        compile_row = Adw::ActionRow.new
+        compile_row.title = 'Compile Rules'
+        compile_row.subtitle = 'Run compilation via D-Bus service'
+        compile_row.activatable = true
+        compile_row.signal_connect('activated') { safe_action(:on_compile_clicked) }
+        compile_row.add_suffix(Gtk::Image.new(icon_name: 'go-next-symbolic'))
+        group.add(compile_row)
+
+        group
+      end
+
+      def build_app_menu
+        menu = Gio::Menu.new
+        menu.append('Preferences', 'app.preferences')
+        menu.append('About', 'app.about')
+        menu.append('Quit', 'app.quit')
+        menu
+      end
+
+      # ========== Action Setup ==========
+
+      def setup_actions
+        setup_preferences_action
+        setup_about_action
+        setup_quit_action
+      end
+
+      def setup_preferences_action
+        prefs_action = Gio::SimpleAction.new('preferences', nil)
+        prefs_action.signal_connect('activate') { safe_action(:show_preferences) }
+        @application.add_action(prefs_action)
+      end
+
+      def setup_about_action
+        about_action = Gio::SimpleAction.new('about', nil)
+        about_action.signal_connect('activate') { safe_action(:show_about) }
+        @application.add_action(about_action)
+      end
+
+      def setup_quit_action
+        quit_action = Gio::SimpleAction.new('quit', nil)
+        quit_action.signal_connect('activate') { @application.quit }
+        @application.add_action(quit_action)
+        @application.set_accels_for_action('app.quit', ['<Control>q'])
+      end
+
+      # ========== Action Handlers ==========
+
+      def show_preferences
+        dialog = Gtk4Preferences.new(@window, @dbus_client)
+        dialog.present
+      end
+
+      def show_about
+        about = Adw::AboutWindow.new
+        about.transient_for = @window
+        about.application_name = 'NeatNerds Code Companion'
+        about.application_icon = APPLICATION_ID
+        about.version = safe_version
+        about.developer_name = 'NeatNerds'
+        about.website = 'https://neatnerds.be'
+        about.issue_url = 'https://github.com/NeatNerds/rosett-ai/issues'
+        about.license_type = Gtk::License::GPL_3_0_ONLY
+        about.copyright = '2026 Hugo Antonio Sepulveda Manriquez / NeatNerds'
+        about.present
+      end
+
+      def on_compile_clicked
+        unless @dbus_client.service_available?
+          show_toast('D-Bus service not available. Start with: rai dbus start')
+          return
+        end
+
+        result = @dbus_client.compile
+        show_toast(result)
+      end
+
+      # ========== Toast & Dialog Helpers ==========
+
+      def show_toast(message)
+        return unless @toast_overlay
+
+        toast = Adw::Toast.new(message.to_s)
+        toast.timeout = 3
+        @toast_overlay.add_toast(toast)
+      rescue StandardError => e
+        log_error('Toast display failed', e)
+      end
+
+      def show_error_dialog(title, message)
+        return unless @window
+
+        dialog = Adw::MessageDialog.new(@window, title, message)
+        dialog.add_response('ok', 'OK')
+        dialog.default_response = 'ok'
+        dialog.present
+      rescue StandardError => e
+        # If dialog fails, at least log it
+        log_error('Error dialog failed', e)
+        warn "[rai] #{title}: #{message}"
+      end
+
+      def show_fatal_error(message)
+        warn "[rai] FATAL: #{message}"
+        # Try to show a basic GTK dialog if possible
+        return unless defined?(Gtk) && Gtk.respond_to?(:init)
+
+        Gtk.init
+        dialog = Gtk::MessageDialog.new(
+          message: message,
+          type: :error,
+          buttons: :close
+        )
+        dialog.run
+        dialog.destroy
+      rescue StandardError
+        # Last resort - just print to stderr
+        nil
+      end
+
+      # ========== Status Text Helpers ==========
+      # All methods return safe strings, never raise
+
+      def dbus_status_text
+        @dbus_client.service_available? ? 'Connected' : 'Not available'
+      rescue StandardError
+        'Unknown'
+      end
+
+      def current_context_text
+        return 'Service not running' unless @dbus_client.service_available?
+
+        status = @dbus_client.status
+        status['current_context'] || 'default'
+      rescue StandardError
+        'Unknown'
+      end
+
+      def current_focus_text
+        return 'Service not running' unless @dbus_client.service_available?
+
+        app_id, title = @dbus_client.current_focus
+        return 'None' if app_id.nil? || app_id.empty?
+
+        "#{app_id}: #{title}"
+      rescue StandardError
+        'Unknown'
+      end
+
+      def safe_version
+        defined?(RosettAi::VERSION) ? RosettAi::VERSION : '0.0.0'
+      rescue StandardError
+        '0.0.0'
+      end
+
+      # ========== Logging ==========
+
+      def log_error(context, error)
+        GuiLogger.error(context, error, component: 'Gtk4App')
+
+        return unless defined?(RosettAi.logger) && RosettAi.logger
+
+        RosettAi.logger.error("[Gtk4App] #{context}: #{error.class} - #{error.message}")
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rosett_ai/desktop/gtk4_preferences.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require_relative 'gui_logger'
+
+module RosettAi
+  module Desktop
+    # Preferences dialog for GTK4 app using AdwPreferencesDialog.
+    #
+    # SAFETY PRINCIPLES:
+    # 1. All callbacks are wrapped with safe_callback() - NEVER crash on user action
+    # 2. D-Bus client operations are defensive - always handle failures gracefully
+    # 3. Missing libadwaita features degrade gracefully
+    # 4. All status queries have rescue blocks
+    #
+    # Follows GNOME HIG instant-apply pattern - changes are applied
+    # immediately via D-Bus, no OK/Apply buttons.
+    class Gtk4Preferences
+      def initialize(parent_window, dbus_client)
+        @parent = parent_window
+        @dbus_client = dbus_client
+        @dialog = nil
+      end
+
+      # Build and return the preferences dialog.
+      # SAFETY: Returns nil on failure instead of raising.
+      #
+      # @return [Adw::PreferencesDialog, nil]
+      def build
+        require 'adwaita'
+        Object.const_set(:Adw, Adwaita) unless Object.const_defined?(:Adw)
+
+        # Try PreferencesDialog first (libadwaita 1.4+), fall back to PreferencesWindow
+        @dialog = create_preferences_dialog
+        return nil unless @dialog
+
+        safe_add_page(:add_general_page)
+        safe_add_page(:add_context_page)
+        safe_add_page(:add_advanced_page)
+
+        @dialog
+      rescue StandardError => e
+        log_error('Failed to build preferences dialog', e)
+        nil
+      end
+
+      # Present the preferences dialog.
+      # SAFETY: Silently fails if dialog cannot be built.
+      def present
+        GuiLogger.action(:present_preferences) do
+          build unless @dialog
+          return unless @dialog
+
+          # PreferencesDialog (1.4+) uses present(parent), PreferencesWindow (1.0+) uses present()
+          # Use defined? check since PreferencesDialog may not exist in older libadwaita
+          if defined?(Adw::PreferencesDialog) && @dialog.is_a?(Adw::PreferencesDialog)
+            @dialog.present(@parent)
+          else
+            @dialog.transient_for = @parent if @dialog.respond_to?(:transient_for=)
+            @dialog.present
+          end
+        end
+      rescue StandardError => e
+        log_error('Failed to present preferences dialog', e)
+      end
+
+      FALLBACK_ENGINES = [
+        { name: 'claude', display_name: 'Claude' },
+        { name: 'generic', display_name: 'Generic' },
+        { name: 'agents_md', display_name: 'AGENTS.md' }
+      ].freeze
+
+      private
+
+      # Create preferences dialog with fallback for older libadwaita.
+      #
+      # @return [Object, nil] PreferencesDialog or PreferencesWindow
+      def create_preferences_dialog
+        # Try PreferencesDialog first (libadwaita 1.4+)
+        if defined?(Adw::PreferencesDialog)
+          dialog = Adw::PreferencesDialog.new
+          dialog.title = 'Preferences'
+          return dialog
+        end
+
+        # Fall back to PreferencesWindow (libadwaita 1.0+)
+        if defined?(Adw::PreferencesWindow)
+          window = Adw::PreferencesWindow.new
+          window.title = 'Preferences'
+          return window
+        end
+
+        log_error('No preferences dialog available', StandardError.new('libadwaita too old'))
+        nil
+      rescue StandardError => e
+        log_error('Failed to create preferences dialog', e)
+        nil
+      end
+
+      # Safely add a page, catching any errors.
+      #
+      # @param method_name [Symbol] page builder method to call
+      def safe_add_page(method_name)
+        send(method_name)
+      rescue StandardError => e
+        log_error("Failed to add page #{method_name}", e)
+      end
+
+      # Wrap callback execution with error handling.
+      #
+      # @param name [String] callback name for logging
+      # @yield the callback block
+      def safe_callback(name)
+        GuiLogger.callback(name, component: 'Gtk4Preferences')
+        yield
+      rescue StandardError => e
+        log_error("Callback #{name} failed", e)
+      end
+
+      def add_general_page
+        page = Adw::PreferencesPage.new
+        page.title = 'General'
+        page.icon_name = 'preferences-system-symbolic'
+
+        # Compilation group
+        compile_group = Adw::PreferencesGroup.new
+        compile_group.title = 'Compilation'
+        compile_group.description = 'Configure rule compilation behaviour'
+
+        # Verbose mode switch
+        verbose_row = create_switch_row(
+          'Verbose Output',
+          'Show detailed compilation messages'
+        ) { |active| safe_callback('verbose') { on_verbose_changed(active) } }
+        compile_group.add(verbose_row) if verbose_row
+
+        # Strict mode switch
+        strict_row = create_switch_row(
+          'Strict Mode',
+          'Treat warnings as errors'
+        ) { |active| safe_callback('strict') { on_strict_changed(active) } }
+        compile_group.add(strict_row) if strict_row
+
+        page.add(compile_group)
+
+        # Engine group
+        engine_group = Adw::PreferencesGroup.new
+        engine_group.title = 'Engine'
+        engine_group.description = 'Default compilation engine'
+
+        engine_row = create_combo_row(
+          'Default Engine',
+          'Engine used when not specified',
+          engine_display_names
+        ) { |index| safe_callback('engine') { on_engine_changed(index) } }
+        engine_group.add(engine_row) if engine_row
+
+        page.add(engine_group)
+        @dialog.add(page)
+      end
+
+      def add_context_page
+        page = Adw::PreferencesPage.new
+        page.title = 'Contexts'
+        page.icon_name = 'view-list-symbolic'
+
+        # Current context group
+        context_group = Adw::PreferencesGroup.new
+        context_group.title = 'Context Switching'
+        context_group.description = 'AI context configuration'
+
+        # Auto-switch toggle
+        auto_switch_row = create_switch_row(
+          'Automatic Context Switching',
+          'Switch context based on focused application'
+        ) { |active| safe_callback('auto_switch') { on_auto_switch_changed(active) } }
+        context_group.add(auto_switch_row) if auto_switch_row
+
+        page.add(context_group)
+        @dialog.add(page)
+      end
+
+      def add_advanced_page
+        page = Adw::PreferencesPage.new
+        page.title = 'Advanced'
+        page.icon_name = 'applications-engineering-symbolic'
+
+        # D-Bus group
+        dbus_group = Adw::PreferencesGroup.new
+        dbus_group.title = 'D-Bus Service'
+        dbus_group.description = 'Service connection settings'
+
+        # Status row
+        status_row = Adw::ActionRow.new
+        status_row.title = 'Service Status'
+        status_row.subtitle = service_status_text
+        dbus_group.add(status_row)
+
+        # Reconnect button
+        reconnect_row = Adw::ActionRow.new
+        reconnect_row.title = 'Reconnect'
+        reconnect_row.subtitle = 'Reconnect to D-Bus service'
+        reconnect_row.activatable = true
+        reconnect_row.signal_connect('activated') do
+          safe_callback('reconnect') { on_reconnect_clicked }
+        end
+        reconnect_row.add_suffix(Gtk::Image.new(icon_name: 'view-refresh-symbolic'))
+        dbus_group.add(reconnect_row)
+
+        page.add(dbus_group)
+        @dialog.add(page)
+      end
+
+      # ========== Widget Factories ==========
+      # These handle missing widget types gracefully
+
+      def create_switch_row(title, subtitle, &block)
+        return nil unless defined?(Adw::SwitchRow)
+
+        row = Adw::SwitchRow.new
+        row.title = title
+        row.subtitle = subtitle
+        row.signal_connect('notify::active') { |r| yield(r.active?) } if block
+        row
+      rescue StandardError => e
+        log_error("Failed to create switch row '#{title}'", e)
+        nil
+      end
+
+      def create_combo_row(title, subtitle, options, &block)
+        return nil unless defined?(Adw::ComboRow)
+
+        row = Adw::ComboRow.new
+        row.title = title
+        row.subtitle = subtitle
+        model = Gtk::StringList.new(options)
+        row.model = model
+        row.signal_connect('notify::selected') { |r| yield(r.selected) } if block
+        row
+      rescue StandardError => e
+        log_error("Failed to create combo row '#{title}'", e)
+        nil
+      end
+
+      # ========== Engine Helpers ==========
+
+      def engine_list
+        engines = @dbus_client.list_engines
+        engines.empty? ? FALLBACK_ENGINES : engines
+      rescue StandardError
+        FALLBACK_ENGINES
+      end
+
+      def engine_display_names
+        engine_list.map { |e| e[:display_name] || e['display_name'] || e[:name] || e['name'] }
+      end
+
+      def engine_names
+        engine_list.map { |e| e[:name] || e['name'] }
+      end
+
+      # ========== Status Helpers ==========
+
+      def service_status_text
+        return 'Not connected' unless @dbus_client.service_available?
+
+        status = @dbus_client.status
+        version = status['version'] || 'unknown'
+        "Connected (v#{version})"
+      rescue StandardError
+        'Unknown'
+      end
+
+      # ========== Callbacks ==========
+      # These are called via safe_callback, so they can safely log/update state
+
+      def on_verbose_changed(active)
+        log_debug("Verbose mode: #{active}")
+        @dbus_client.set_config('verbose', active.to_s)
+      end
+
+      def on_strict_changed(active)
+        log_debug("Strict mode: #{active}")
+        @dbus_client.set_config('strict', active.to_s)
+      end
+
+      def on_engine_changed(index)
+        names = engine_names
+        engine = names[index] || 'claude'
+        log_debug("Engine changed: #{engine}")
+        @dbus_client.set_config('default_engine', engine)
+      end
+
+      def on_auto_switch_changed(active)
+        log_debug("Auto-switch: #{active}")
+        @dbus_client.set_config('auto_switch', active.to_s)
+      end
+
+      def on_reconnect_clicked
+        @dbus_client.disconnect
+        connected = @dbus_client.connect
+        log_debug("Reconnect attempt: #{connected ? 'success' : 'failed'}")
+        # Would update status row when we have a reference to it
+      end
+
+      # ========== Logging ==========
+
+      def log_error(context, error)
+        GuiLogger.error(context, error, component: 'Gtk4Preferences')
+
+        return unless defined?(RosettAi.logger) && RosettAi.logger
+
+        RosettAi.logger.error("[Gtk4Preferences] #{context}: #{error.class} - #{error.message}")
+      rescue StandardError
+        nil
+      end
+
+      def log_debug(message)
+        GuiLogger.debug(message, component: 'Gtk4Preferences')
+
+        return unless defined?(RosettAi.logger) && RosettAi.logger
+
+        RosettAi.logger.debug("[Gtk4Preferences] #{message}")
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end