fantasy-cli 1.2.14 → 1.3.0

data/lib/gsd/plugins/hooks.rb

@@ -1,131 +1,153 @@
 # frozen_string_literal: true
 
+require 'singleton'
+
 module Gsd
   module Plugins
-    # Plugin Hooks - Sistema de hooks para plugins
+    # Plugin Hooks - Sistema de hooks/pub-sub para plugins
+    #
+    # Implementa um sistema de eventos pub/sub onde plugins podem:
+    # - Se registrar para eventos específicos
+    # - Emitir eventos para outros plugins
+    # - Usar wildcards para capturar múltiplos eventos
     #
-    # Responsável por:
-    # - Registrar hooks de plugins
-    # - Executar hooks em eventos
-    # - Gerenciar prioridade de hooks
+    # @example
+    #   hooks = Hooks.instance
+    #   hooks.on('event.name') { |data| puts data }
+    #   hooks.trigger('event.name', { foo: 'bar' })
     class Hooks
-      attr_reader :hooks
-
-      # Hook types
-      HOOK_TYPES = [
-        :pre_command,
-        :post_command,
-        :pre_tool,
-        :post_tool,
-        :pre_commit,
-        :post_phase,
-        :on_enable,
-        :on_disable
-      ].freeze
-
-      # Inicializa o Hooks
+      include Singleton
+
+      attr_reader :handlers, :history
+
       def initialize
-        @hooks = {}
-        HOOK_TYPES.each { |type| @hooks[type] = [] }
+        @handlers = {}
+        @mutex = Mutex.new
+        @history = []
+        @history_limit = 100
       end
 
-      # Registra um hook
+      # Registra um handler para um evento (API pub/sub)
       #
-      # @param type [Symbol] Tipo do hook
-      # @param plugin [String] Nome do plugin
-      # @param callback [Proc] Callback para executar
-      # @param priority [Integer] Prioridade (maior = primeiro)
-      # @return [void]
-      def register(type, plugin, callback, priority: 0)
-        unless HOOK_TYPES.include?(type)
-          raise ArgumentError, "Invalid hook type: #{type}"
+      # @param event [String, Symbol] Nome do evento (pode usar wildcards *)
+      # @param priority [Integer] Prioridade (maior = primeiro, default: 0)
+      # @param block [Proc] Handler
+      def on(event, priority: 0, &block)
+        @mutex.synchronize do
+          event = event.to_s
+          @handlers[event] ||= []
+          @handlers[event] << { block: block, priority: priority }
+          @handlers[event].sort_by! { |h| -h[:priority] }
         end
+      end
 
-        @hooks[type] << {
-          plugin: plugin,
-          callback: callback,
-          priority: priority,
-          registered_at: Time.now
-        }
-
-        # Ordena por prioridade
-        @hooks[type].sort_by! { |h| -h[:priority] }
+      # Emite um evento para todos os handlers registrados (alias para trigger)
+      def emit(event, *args)
+        trigger(event, *args)
       end
 
-      # Remove hook de um plugin
-      #
-      # @param plugin [String] Nome do plugin
-      # @return [void]
-      def unregister(plugin)
-        @hooks.each do |type, hook_list|
-          @hooks[type] = hook_list.reject { |h| h[:plugin] == plugin }
-        end
+      # Dispara hooks para um evento (alias para trigger)
+      def run(event, context = {})
+        trigger(event, context)
       end
 
-      # Executa hooks de um tipo
+      # Emite um evento para todos os handlers registrados
       #
-      # @param type [Symbol] Tipo do hook
-      # @param context [Hash] Contexto para o hook
-      # @return [Array] Resultados dos hooks
-      def run(type, context = {})
-        unless HOOK_TYPES.include?(type)
-          raise ArgumentError, "Invalid hook type: #{type}"
-        end
-
+      # @param event [String, Symbol] Nome do evento
+      # @param args [Array] Argumentos para os handlers
+      # @return [Array] Retornos de todos os handlers
+      def trigger(event, *args)
+        event = event.to_s
         results = []
-        @hooks[type].each do |hook|
+
+        log_event(event, args)
+        handlers = matching_handlers(event)
+
+        handlers.each do |handler|
           begin
-            result = hook[:callback].call(context)
-            results << {
-              plugin: hook[:plugin],
-              result: result,
-              success: true
-            }
-          rescue => e
-            results << {
-              plugin: hook[:plugin],
-              error: e.message,
-              success: false
-            }
-            warn "[Hooks] Error in #{type} hook (#{hook[:plugin]}): #{e.message}"
+            result = handler[:block].call(*args)
+            results << result
+          rescue StandardError => e
+            warn "[Hooks] Error in handler for '#{event}': #{e.message}"
           end
         end
 
         results
       end
 
-      # Lista hooks registrados
-      #
-      # @param type [Symbol, nil] Tipo específico
-      # @return [Array<Hash>] Lista de hooks
-      def list(type = nil)
-        if type
-          @hooks[type] || []
-        else
-          @hooks
-        end
+      # Verifica se há handlers para um evento
+      def has_handlers?(event)
+        event = event.to_s
+        !matching_handlers(event).empty?
       end
 
-      # Conta hooks por tipo
-      #
-      # @return [Hash] Contagem por tipo
+      # Remove um handler (não implementado na API pub/sub)
+      def unregister(plugin)
+        @handlers.delete_if { |_, handlers| handlers.any? { |h| h[:plugin] == plugin } }
+      end
+
+      # Lista todos os eventos registrados
+      def events
+        @mutex.synchronize { @handlers.keys.dup }
+      end
+
+      # Conta handlers por evento
       def count
-        @hooks.transform_values(&:count)
+        @handlers.transform_values(&:count)
       end
 
-      # Limpa todos os hooks
-      #
-      # @return [void]
+      # Limpa todos os handlers
       def clear
-        HOOK_TYPES.each { |type| @hooks[type] = [] }
+        @mutex.synchronize do
+          @handlers.clear
+          @history.clear
+        end
       end
 
-      # Limpa hooks de um tipo
-      #
-      # @param type [Symbol] Tipo do hook
-      # @return [void]
-      def clear_type(type)
-        @hooks[type] = [] if HOOK_TYPES.include?(type)
+      # Histórico de eventos
+      def event_history(event = nil)
+        if event
+          @history.select { |h| h[:event] == event.to_s }
+        else
+          @history.dup
+        end
+      end
+
+      private
+
+      def matching_handlers(event)
+        @mutex.synchronize do
+          handlers = []
+
+          @handlers.each do |pattern, pattern_handlers|
+            if match_pattern?(event, pattern)
+              handlers.concat(pattern_handlers)
+            end
+          end
+
+          handlers.uniq.sort_by { |h| -h[:priority] }
+        end
+      end
+
+      def match_pattern?(event, pattern)
+        return true if pattern == event
+        return true if pattern.end_with?('.*') && event.start_with?(pattern[0..-2])
+        return true if pattern.start_with?('*') && event.end_with?(pattern[1..-1])
+        return true if pattern.include?('*') && event =~ Regexp.new(pattern.gsub('.', '\.').gsub('*', '.*'))
+
+        false
+      end
+
+      def log_event(event, args)
+        @mutex.synchronize do
+          @history << {
+            event: event,
+            args: args.map { |a| a.respond_to?(:to_h) ? a.to_h : a.to_s },
+            timestamp: Time.now.to_f
+          }
+
+          @history.shift while @history.length > @history_limit
+        end
       end
     end
   end

data/lib/gsd/plugins/hot_reload.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'digest'
+
+module Gsd
+  module Plugins
+    # HotReload - Sistema de hot-reload para plugins
+    #
+    # Monitora arquivos de plugins e recarrega automaticamente
+    # quando detecta mudanças.
+    class HotReload
+      attr_reader :watching, :check_interval, :last_check
+
+      def initialize(registry: nil, loader: nil, interval: 1.0)
+        @registry = registry || Registry.instance
+        @loader = loader || Loader.new(registry: @registry)
+        @check_interval = interval
+        @watched_files = {}
+        @file_hashes = {}
+        @watching = false
+        @watcher_thread = nil
+        @mutex = Mutex.new
+        @on_change_callbacks = []
+      end
+
+      # Inicia monitoramento
+      def start
+        return if @watching
+
+        @watching = true
+        scan_files
+
+        @watcher_thread = Thread.new do
+          while @watching
+            check_changes
+            sleep(@check_interval)
+          end
+        end
+
+        true
+      end
+
+      # Para monitoramento
+      def stop
+        @watching = false
+        @watcher_thread&.kill
+        @watcher_thread = nil
+      end
+
+      # Adiciona arquivo para monitoramento
+      def watch(path, plugin_name = nil)
+        @mutex.synchronize do
+          @watched_files[path] = {
+            plugin: plugin_name || extract_plugin_name(path),
+            last_modified: File.mtime(path),
+            hash: file_hash(path)
+          }
+        end
+      end
+
+      # Remove arquivo do monitoramento
+      def unwatch(path)
+        @mutex.synchronize do
+          @watched_files.delete(path)
+        end
+      end
+
+      # Verifica mudanças manualmente
+      def check_changes
+        changes = []
+
+        @mutex.synchronize do
+          @watched_files.each do |path, info|
+            next unless File.exist?(path)
+
+            current_mtime = File.mtime(path)
+            current_hash = file_hash(path)
+
+            if current_mtime > info[:last_modified] || current_hash != info[:hash]
+              changes << {
+                path: path,
+                plugin: info[:plugin],
+                old_mtime: info[:last_modified],
+                new_mtime: current_mtime
+              }
+
+              # Atualiza info
+              @watched_files[path][:last_modified] = current_mtime
+              @watched_files[path][:hash] = current_hash
+            end
+          end
+        end
+
+        # Processa mudanças
+        changes.each do |change|
+          handle_change(change)
+        end
+
+        changes
+      end
+
+      # Registra callback para mudanças
+      def on_change(&block)
+        @on_change_callbacks << block
+      end
+
+      # Lista arquivos sendo monitorados
+      def watched
+        @mutex.synchronize { @watched_files.dup }
+      end
+
+      # Recarrega um plugin específico
+      def reload_plugin(name)
+        return false unless @registry.exists?(name)
+
+        begin
+          @loader.reload(name)
+          trigger_change_callbacks(:reloaded, name)
+          true
+        rescue StandardError => e
+          warn "[HotReload] Failed to reload plugin '#{name}': #{e.message}"
+          false
+        end
+      end
+
+      # Força recarregamento de todos os plugins
+      def reload_all
+        @registry.all.each do |plugin|
+          reload_plugin(plugin.name)
+        end
+      end
+
+      # Pausa monitoramento temporariamente
+      def pause
+        @paused = true
+      end
+
+      # Retoma monitoramento
+      def resume
+        @paused = false
+      end
+
+      # Status atual
+      def status
+        {
+          watching: @watching,
+          paused: @paused,
+          files_watched: @watched_files.length,
+          last_check: @last_check
+        }
+      end
+
+      private
+
+      def scan_files
+        return unless Dir.exist?(@registry.plugins_dir)
+
+        Dir.glob(File.join(@registry.plugins_dir, '*', 'plugin.rb')).each do |path|
+          watch(path)
+        end
+      end
+
+      def file_hash(path)
+        return nil unless File.exist?(path)
+
+        Digest::MD5.file(path).hexdigest
+      rescue StandardError
+        nil
+      end
+
+      def extract_plugin_name(path)
+        File.basename(File.dirname(path))
+      end
+
+      def handle_change(change)
+        return if @paused
+
+        @last_check = Time.now
+
+        plugin_name = change[:plugin]
+        return unless plugin_name
+
+        # Notifica callbacks
+        trigger_change_callbacks(:detected, plugin_name, change[:path])
+
+        # Recarrega plugin
+        reload_plugin(plugin_name)
+      end
+
+      def trigger_change_callbacks(type, plugin_name, path = nil)
+        @on_change_callbacks.each do |callback|
+          begin
+            callback.call(type, plugin_name, path)
+          rescue StandardError => e
+            warn "[HotReload] Error in change callback: #{e.message}"
+          end
+        end
+      end
+    end
+
+    # FileWatcher - Watcher simples para arquivos individuais
+    class FileWatcher
+      def initialize(path, &callback)
+        @path = path
+        @callback = callback
+        @last_mtime = File.exist?(path) ? File.mtime(path) : nil
+        @running = false
+      end
+
+      def start(interval: 1.0)
+        return if @running
+
+        @running = true
+
+        Thread.new do
+          while @running
+            check
+            sleep(interval)
+          end
+        end
+      end
+
+      def stop
+        @running = false
+      end
+
+      def check
+        return unless File.exist?(@path)
+
+        current_mtime = File.mtime(@path)
+
+        if @last_mtime && current_mtime > @last_mtime
+          @callback.call(@path, @last_mtime, current_mtime)
+        end
+
+        @last_mtime = current_mtime
+      end
+    end
+
+    # DebouncedWatcher - Watcher com debounce para evitar múltiplos reloads
+    class DebouncedWatcher
+      def initialize(registry:, debounce_time: 0.5)
+        @registry = registry
+        @debounce_time = debounce_time
+        @pending_changes = {}
+        @mutex = Mutex.new
+      end
+
+      def notify_change(plugin_name, path)
+        @mutex.synchronize do
+          @pending_changes[plugin_name] = {
+            path: path,
+            time: Time.now
+          }
+        end
+
+        # Inicia timer se não estiver rodando
+        start_debounce_timer
+      end
+
+      private
+
+      def start_debounce_timer
+        Thread.new do
+          sleep(@debounce_time)
+          process_pending
+        end
+      end
+
+      def process_pending
+        changes = []
+
+        @mutex.synchronize do
+          now = Time.now
+          @pending_changes.each do |plugin, info|
+            if now - info[:time] >= @debounce_time
+              changes << plugin
+            end
+          end
+
+          # Remove processados
+          changes.each { |p| @pending_changes.delete(p) }
+        end
+
+        # Recarrega plugins
+        changes.each do |plugin_name|
+          HotReload.new.reload_plugin(plugin_name)
+        end
+      end
+    end
+  end
+end