fantasy-cli 1.2.14 → 1.3.0

data/lib/gsd/plugins/registry.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module Gsd
+  module Plugins
+    # Plugin - Representa um plugin individual
+    #
+    # Cada plugin tem:
+    # - Metadata (nome, versão, autor, descrição)
+    # - Estado (enabled/disabled)
+    # - Hooks registrados
+    # - Dependências
+    class Plugin
+      attr_reader :name, :version, :author, :description, :path, :hooks
+      attr_accessor :enabled
+
+      def initialize(name:, version:, path:, author: nil, description: nil, dependencies: [])
+        @name = name
+        @version = version
+        @path = path
+        @author = author || 'Unknown'
+        @description = description || 'No description'
+        @dependencies = dependencies
+        @enabled = false
+        @hooks = {}
+        @instance = nil
+      end
+
+      # Ativa o plugin
+      def enable!
+        return true if @enabled
+
+        # Verifica dependências
+        missing = check_dependencies
+        unless missing.empty?
+          raise PluginError, "Missing dependencies: #{missing.join(', ')}"
+        end
+
+        @enabled = true
+        trigger_hook(:enable)
+        true
+      end
+
+      # Desativa o plugin
+      def disable!
+        return true unless @enabled
+
+        trigger_hook(:disable)
+        @enabled = false
+        true
+      end
+
+      # Registra um hook
+      def register_hook(event, &block)
+        @hooks[event] ||= []
+        @hooks[event] << block
+      end
+
+      # Dispara hooks para um evento
+      def trigger_hook(event, *args)
+        return unless @hooks[event]
+
+        @hooks[event].each { |h| h.call(*args) }
+      end
+
+      # Verifica dependências
+      def check_dependencies
+        registry = Registry.instance
+        @dependencies.reject { |dep| registry.get(dep) }
+      end
+
+      # Converte para hash
+      def to_h
+        {
+          name: @name,
+          version: @version,
+          author: @author,
+          description: @description,
+          enabled: @enabled,
+          dependencies: @dependencies,
+          path: @path
+        }
+      end
+
+      # Carrega código do plugin
+      def load!
+        return if @loaded
+
+        if File.exist?(@path)
+          require @path
+          @loaded = true
+          trigger_hook(:load)
+        end
+      end
+    end
+
+    # PluginError - Exceção para erros de plugin
+    class PluginError < StandardError; end
+
+    # Registry - Registro central de plugins
+    #
+    # Singleton que gerencia todos os plugins instalados
+    class Registry
+      include Singleton
+
+      attr_reader :plugins_dir
+
+      def initialize
+        @plugins = {}
+        @mutex = Mutex.new
+        @plugins_dir = File.join(Dir.home, '.gsd', 'plugins')
+        ensure_plugins_dir
+      end
+
+      # Registra um novo plugin
+      def register(plugin)
+        @mutex.synchronize do
+          if @plugins[plugin.name]
+            raise PluginError, "Plugin '#{plugin.name}' already registered"
+          end
+
+          @plugins[plugin.name] = plugin
+        end
+      end
+
+      # Remove um plugin
+      def unregister(name)
+        @mutex.synchronize do
+          plugin = @plugins[name]
+          if plugin
+            plugin.disable! if plugin.enabled
+            @plugins.delete(name)
+          end
+        end
+      end
+
+      # Obtém um plugin pelo nome
+      def get(name)
+        @mutex.synchronize { @plugins[name] }
+      end
+
+      # Lista todos os plugins
+      def all
+        @mutex.synchronize { @plugins.values.dup }
+      end
+
+      # Lista plugins habilitados
+      def enabled
+        @mutex.synchronize { @plugins.values.select(&:enabled) }
+      end
+
+      # Verifica se plugin existe
+      def exists?(name)
+        @mutex.synchronize { @plugins.key?(name) }
+      end
+
+      # Habilita um plugin
+      def enable(name)
+        plugin = get(name)
+        raise PluginError, "Plugin '#{name}' not found" unless plugin
+
+        plugin.enable!
+      end
+
+      # Desabilita um plugin
+      def disable(name)
+        plugin = get(name)
+        raise PluginError, "Plugin '#{name}' not found" unless plugin
+
+        plugin.disable!
+      end
+
+      # Busca plugins por nome/padrão
+      def search(pattern)
+        regex = Regexp.new(pattern, Regexp::IGNORECASE)
+        @mutex.synchronize do
+          @plugins.values.select { |p| p.name =~ regex || p.description =~ regex }
+        end
+      end
+
+      # Lista plugins que podem ser carregados do disco
+      def discover
+        discovered = []
+        return discovered unless Dir.exist?(@plugins_dir)
+
+        Dir.glob(File.join(@plugins_dir, '*', 'plugin.rb')).each do |path|
+          begin
+            metadata = load_metadata(path)
+            discovered << Plugin.new(
+              name: metadata[:name],
+              version: metadata[:version],
+              path: path,
+              author: metadata[:author],
+              description: metadata[:description],
+              dependencies: metadata[:dependencies] || []
+            )
+          rescue StandardError => e
+            warn "Failed to load plugin from #{path}: #{e.message}"
+          end
+        end
+
+        discovered
+      end
+
+      # Carrega plugin do disco e registra
+      def load_from_disk(name)
+        path = File.join(@plugins_dir, name, 'plugin.rb')
+        return nil unless File.exist?(path)
+
+        metadata = load_metadata(path)
+        plugin = Plugin.new(
+          name: metadata[:name],
+          version: metadata[:version],
+          path: path,
+          author: metadata[:author],
+          description: metadata[:description],
+          dependencies: metadata[:dependencies] || []
+        )
+
+        register(plugin)
+        plugin
+      end
+
+      # Salva estado dos plugins
+      def save_state(path = nil)
+        path ||= File.join(Dir.home, '.gsd', 'plugins.json')
+        state = {
+          enabled: enabled.map(&:name),
+          all: all.map(&:to_h)
+        }
+        File.write(path, JSON.pretty_generate(state))
+      end
+
+      # Carrega estado dos plugins
+      def load_state(path = nil)
+        path ||= File.join(Dir.home, '.gsd', 'plugins.json')
+        return unless File.exist?(path)
+
+        state = JSON.parse(File.read(path), symbolize_names: true)
+        state[:enabled].each { |name| enable(name) rescue nil }
+      end
+
+      private
+
+      def ensure_plugins_dir
+        FileUtils.mkdir_p(@plugins_dir) unless Dir.exist?(@plugins_dir)
+      end
+
+      def load_metadata(path)
+        # Extrai metadata de um arquivo plugin.rb
+        content = File.read(path)
+        metadata = {}
+
+        # Procura por comentários de metadata
+        if content =~ /#\s*@name\s+(\S+)/
+          metadata[:name] = $1
+        else
+          metadata[:name] = File.basename(File.dirname(path))
+        end
+
+        metadata[:version] = $1 if content =~ /#\s*@version\s+(\S+)/
+        metadata[:author] = $1 if content =~ /#\s*@author\s+(.+)/
+        metadata[:description] = $1 if content =~ /#\s*@description\s+(.+)/
+
+        if content =~ /#\s*@dependencies\s+(.+)/
+          metadata[:dependencies] = $1.split(',').map(&:strip)
+        end
+
+        metadata[:version] ||= '0.1.0'
+        metadata
+      end
+    end
+  end
+end

data/lib/gsd/tui/agent_panel.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'gsd/tui/colors'
+
+module Gsd
+  module TUI
+    # AgentPanel - UI component for managing agents in the TUI
+    #
+    # Displays:
+    # - List of active agents with status
+    # - Agent types and current tasks
+    # - Quick actions (spawn, terminate, restart)
+    # - Communication between agents
+    class AgentPanel
+      def initialize(swarm, width: 60, visible: false)
+        @swarm = swarm
+        @width = width
+        @visible = visible
+        @selected_index = 0
+        @scroll_offset = 0
+      end
+
+      def show
+        @visible = true
+        refresh
+      end
+
+      def hide
+        @visible = false
+      end
+
+      def visible?
+        @visible
+      end
+
+      def toggle
+        @visible = !@visible
+        refresh if @visible
+      end
+
+      def move_up
+        return unless @visible
+        @selected_index = [@selected_index - 1, 0].max
+        adjust_scroll
+      end
+
+      def move_down
+        return unless @visible
+        max_index = [@swarm.list.count - 1, 0].max
+        @selected_index = [@selected_index + 1, max_index].min
+        adjust_scroll
+      end
+
+      def select_current
+        return unless @visible
+        agents = @swarm.list
+        return if agents.empty?
+        
+        agent = agents[@selected_index]
+        agent&.id
+      end
+
+      def render
+        return '' unless @visible
+
+        t = Colors.theme
+        cyan = t[:accent]
+        magenta = t[:accent2]
+        pink = t[:accent3]
+        white = t[:text]
+        dim = t[:dim]
+        bg = t[:bg]
+        reset = Colors::RESET
+
+        lines = []
+        
+        # Header
+        lines << "#{cyan}╭#{('─' * (@width - 2))}╮#{reset}"
+        lines << "#{cyan}│#{reset}  #{magenta}⚡ Agents#{reset}#{dim} (#{@swarm.stats[:total_agents]} active)#{reset}  #{cyan}│#{reset}"
+        lines << "#{cyan}├#{('─' * (@width - 2))}┤#{reset}"
+
+        # Agent list
+        agents = @swarm.list
+        if agents.empty?
+          lines << "#{cyan}│#{reset}  #{dim}No agents running#{reset}  #{cyan}│#{reset}"
+        else
+          display_count = [agents.count, 5].min  # Show max 5 agents
+          display_count.times do |i|
+            idx = @scroll_offset + i
+            break if idx >= agents.count
+            
+            agent = agents[idx]
+            lines << render_agent_line(agent, idx == @selected_index, cyan, magenta, pink, white, dim, reset)
+          end
+        end
+
+        # Footer with actions
+        lines << "#{cyan}├#{('─' * (@width - 2))}┤#{reset}"
+        lines << "#{cyan}│#{reset}  #{dim}↑↓ navigate | s:spawn | t:terminate | r:restart#{reset}  #{cyan}│#{reset}"
+        lines << "#{cyan}╰#{('─' * (@width - 2))}╯#{reset}"
+
+        lines.join("\n")
+      end
+
+      def handle_key(char)
+        return unless @visible
+
+        case char
+        when 's', 'S'
+          :spawn_agent
+        when 't', 'T'
+          :terminate_agent
+        when 'r', 'R'
+          :restart_agent
+        when 'm', 'M'
+          :send_message
+        else
+          nil
+        end
+      end
+
+      private
+
+      def render_agent_line(agent, selected, cyan, magenta, pink, white, dim, reset)
+        # Status indicator
+        status_color = case agent.state
+        when :idle then dim
+        when :working then magenta
+        when :crashed then pink
+        else dim
+        end
+        
+        status_icon = case agent.state
+        when :idle then '○'
+        when :working then '●'
+        when :crashed then '✗'
+        else '○'
+        end
+
+        # Type badge
+        type_badge = case agent.type
+        when :code then "#{cyan}[CODE]#{reset}"
+        when :plan then "#{magenta}[PLAN]#{reset}"
+        when :debug then "#{pink}[DEBUG]#{reset}"
+        else "#{dim}[#{agent.type.to_s.upcase}]#{reset}"
+        end
+
+        # Selection indicator
+        prefix = selected ? "#{cyan}>#{reset}" : "#{dim} #{reset}"
+        
+        # Line content
+        content = "#{prefix} #{status_color}#{status_icon}#{reset} #{type_badge} #{white}#{agent.id[0..12]}#{reset}"
+        
+        # Task info if working
+        if agent.state == :working && agent.instance_variable_get(:@current_task)
+          task_preview = agent.instance_variable_get(:@current_task)[:type] || 'task'
+          content += " #{dim}(#{task_preview})#{reset}"
+        end
+
+        # Pad to width
+        clean_len = content.gsub(/\e\[\d+m/, '').length
+        padding = ' ' * [@width - clean_len - 2, 0].max
+
+        "#{cyan}│#{reset}#{content}#{padding}#{cyan}│#{reset}"
+      end
+
+      def adjust_scroll
+        visible_count = 5
+        
+        if @selected_index < @scroll_offset
+          @scroll_offset = @selected_index
+        elsif @selected_index >= @scroll_offset + visible_count
+          @scroll_offset = @selected_index - visible_count + 1
+        end
+      end
+
+      def refresh
+        # Trigger refresh of parent TUI
+      end
+    end
+  end
+end