fantasy-cli 1.2.14 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5adcd4b07f5da2256106aa2df3bc5ad67ab64d3b62d69dbfb316edc266bf90be
-  data.tar.gz: 2115dd7040fff7fe0fcd20bda97b6e28b7462bc06b3e77bf4e3f738870b5e558
+  metadata.gz: 44d592c83d03126aab712e4f0ffe144439ffde20bda9798974d6d82073222642
+  data.tar.gz: 77b9490266d6e8cec2aeda116b9cc6fb68e080d76294db8a9bfa880e0204617a
 SHA512:
-  metadata.gz: 85abb14e63e9ae8c6aec9ea4e84995c4c9d26f2410f92630fb0335fa5b40d5e325b4530415b2ed3e983d54cf19b0376160eb820efab5c3e3907e367d3a466f33
-  data.tar.gz: 78e547cdc205b0638de16917d78fd6499060a73095ac4d3a35bb12cce1ec049c75e279da8f8d052b59961e75bb7dd232c934679bed0d401847edb74a05642b81
+  metadata.gz: ebfee63b7e36a8502decd98966def7d40371e6109d2e8f0c2b36e7095fe6998d7502543c842c42bbf76a28f379e9042aba69bf408a8a4f2e7c22e643f3d0db1e
+  data.tar.gz: f4d69773cc1d1c06bd31b86f3b87d41c5b4ca48cf3bcebed990c40f02ab96c2c0b9cece32c7226d0373f7727f60cfa313c3e55bc2db6792b4de68f8201d21f01

data/README.md

@@ -17,12 +17,19 @@
 |---------|-----------|
 | 🤖 **AI Chat** | REPL interativo com suporte a múltiplos providers (Anthropic, OpenAI, Ollama, LM Studio, OpenRouter) |
 | 📁 **Referências @** | Injete arquivos (`@arquivo.rb`) e diretórios (`@pasta/`) diretamente no contexto da conversa |
-| ⌨️ **Comandos /** | `/help`, `/model`, `/cost`, `/clear`, `/export` e mais |
+
+| ⌨️ **Comandos /** | `/help`, `/model`, `/cost`, `/clear`, `/export`, `/save`, `/restore`, `/tab`, `/plugin`, `/lsp` e mais |
 | 🔮 **Autocomplete** | Sugestões em tempo real para referências de arquivos |
 | 📊 **Git Context** | Branch, status, arquivos modificados e ahead/behind integrados automaticamente |
 | 💰 **Cost Tracking** | Monitoramento de tokens e custo em tempo real com alertas de orçamento |
 | 🏗️ **Project Management** | State, Phase, Roadmap, Milestones, Workstreams |
 | 📝 **Templates** | Geração automática de docs (SUMMARY.md, PLAN.md, VERIFICATION.md) |
+| 🐝 **Multi-Agent Swarm** | Sistema multi-agente com orquestração automática (v1.3.0) |
+| 💾 **Session Persistence** | Save/restore de sessões, checkpoints, auto-save (v1.3.0) |
+| 📑 **Tabs & Panes** | Múltiplas abas independentes no TUI (v1.3.0) |
+| ✨ **Advanced UI** | Animações, transições, mouse support, efeitos visuais (v1.3.0) |
+| 🔌 **Plugin System** | Hot-reload, hooks, sandbox, API para plugins (v1.3.0) |
+| 🔧 **LSP Integration** | Language Server Protocol para Ruby, Python, JS/TS, Go, Rust (v1.3.0) |
 
 ---
 

data/lib/gsd/agents/communication.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'json'
+
+module Gsd
+  module Agents
+    # Communication - Sistema de mensagens entre agents
+    #
+    # Implementa:
+    # - Message bus para comunicação assíncrona
+    # - Event system para notificações
+    # - Message persistence (opcional)
+    # - Pub/sub patterns
+    class Communication
+      attr_reader :channels, :subscriptions, :message_log
+
+      def initialize(persist_messages: false)
+        @channels = {}         # channel_name => [messages]
+        @subscriptions = {}    # channel_name => [agent_ids]
+        @message_log = []      # Log de todas as mensagens (se persist=true)
+        @persist_messages = persist_messages
+        @mutex = Mutex.new
+      end
+
+      # Cria um canal de comunicação
+      #
+      # @param name [String] Nome do canal
+      def create_channel(name)
+        @mutex.synchronize do
+          @channels[name] ||= []
+          @subscriptions[name] ||= []
+        end
+      end
+
+      # Publica mensagem em um canal
+      #
+      # @param channel [String] Nome do canal
+      # @param message [Hash] Conteúdo da mensagem
+      # @param sender [String] ID do agente remetente
+      def publish(channel:, message:, sender:)
+        @mutex.synchronize do
+          create_channel(channel) unless @channels.key?(channel)
+
+          envelope = Message.new(
+            channel: channel,
+            sender: sender,
+            content: message,
+            timestamp: Time.now
+          )
+
+          @channels[channel] << envelope
+          @message_log << envelope if @persist_messages
+
+          # Notifica subscribers
+          notify_subscribers(channel, envelope)
+        end
+      end
+
+      # Inscreve um agente em um canal
+      #
+      # @param agent_id [String] ID do agente
+      # @param channel [String] Nome do canal
+      def subscribe(agent_id:, channel:)
+        @mutex.synchronize do
+          create_channel(channel) unless @channels.key?(channel)
+          @subscriptions[channel] << agent_id unless @subscriptions[channel].include?(agent_id)
+        end
+      end
+
+      # Cancela inscrição de um agente
+      #
+      # @param agent_id [String] ID do agente
+      # @param channel [String] Nome do canal
+      def unsubscribe(agent_id:, channel:)
+        @mutex.synchronize do
+          @subscriptions[channel]&.delete(agent_id)
+        end
+      end
+
+      # Obtém mensagens não lidas de um canal para um agente
+      #
+      # @param agent_id [String] ID do agente
+      # @param channel [String] Nome do canal
+      # @param since [Time, nil] Timestamp para filtrar mensagens
+      # @return [Array<Message>] Mensagens para o agente
+      def receive(agent_id:, channel:, since: nil)
+        @mutex.synchronize do
+          return [] unless @channels.key?(channel)
+
+          messages = @channels[channel]
+          messages = messages.select { |m| m.timestamp > since } if since
+
+          # Filtra mensagens destinadas a este agente ou broadcast
+          messages.select do |m|
+            m.recipients.nil? || m.recipients.include?(agent_id) || m.sender != agent_id
+          end
+        end
+      end
+
+      # Envia mensagem direta (DM) para agente específico
+      #
+      # @param to [String] ID do destinatário
+      # @param from [String] ID do remetente
+      # @param content [Hash] Conteúdo
+      def direct_message(to:, from:, content:)
+        channel = "dm:#{[to, from].sort.join(':')}"
+        
+        @mutex.synchronize do
+          create_channel(channel)
+          
+          envelope = Message.new(
+            channel: channel,
+            sender: from,
+            recipients: [to],
+            content: content,
+            timestamp: Time.now
+          )
+
+          @channels[channel] << envelope
+          @message_log << envelope if @persist_messages
+        end
+      end
+
+      # Broadcast para todos agents no canal
+      #
+      # @param channel [String] Nome do canal
+      # @param content [Hash] Conteúdo
+      # @param sender [String] ID do remetente
+      def broadcast(channel:, content:, sender:)
+        publish(channel: channel, message: content, sender: sender)
+      end
+
+      # Obtém histórico de mensagens
+      #
+      # @param channel [String, nil] Filtrar por canal (nil = todos)
+      # @param limit [Integer] Limite de mensagens
+      # @return [Array<Message>] Histórico
+      def history(channel: nil, limit: 100)
+        @mutex.synchronize do
+          messages = if channel
+            @channels[channel] || []
+          else
+            @message_log
+          end
+
+          messages.last(limit)
+        end
+      end
+
+      # Limpa mensagens antigas de um canal
+      #
+      # @param channel [String] Nome do canal
+      # @param older_than [Time] Remover mensagens mais antigas que
+      def cleanup(channel:, older_than:)
+        @mutex.synchronize do
+          return unless @channels.key?(channel)
+
+          @channels[channel] = @channels[channel].select { |m| m.timestamp > older_than }
+        end
+      end
+
+      # Estatísticas de comunicação
+      #
+      # @return [Hash] Estatísticas
+      def stats
+        @mutex.synchronize do
+          {
+            channels: @channels.count,
+            total_messages: @channels.values.sum(&:count),
+            subscriptions: @subscriptions.values.sum(&:count),
+            persisted_messages: @message_log.count
+          }
+        end
+      end
+
+      private
+
+      def notify_subscribers(channel, message)
+        # Callback para notificar subscribers externos
+        # Implementação real usaria callbacks ou event system
+      end
+    end
+
+    # Representação de uma mensagem
+    class Message
+      attr_reader :id, :channel, :sender, :recipients, :content, :timestamp
+
+      def initialize(channel:, sender:, content:, timestamp:, recipients: nil)
+        @id = SecureRandom.uuid
+        @channel = channel
+        @sender = sender
+        @recipients = recipients
+        @content = content
+        @timestamp = timestamp
+      end
+
+      def to_h
+        {
+          id: @id,
+          channel: @channel,
+          sender: @sender,
+          recipients: @recipients,
+          content: @content,
+          timestamp: @timestamp.to_s
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      def direct?
+        @recipients.present?
+      end
+
+      def broadcast?
+        @recipients.nil?
+      end
+    end
+
+    # Event System para notificações assíncronas
+    class EventBus
+      def initialize
+        @handlers = {}
+        @mutex = Mutex.new
+      end
+
+      # Registra handler para um evento
+      #
+      # @param event [Symbol] Nome do evento
+      # @param handler [Proc] Handler
+      def on(event, &handler)
+        @mutex.synchronize do
+          @handlers[event] ||= []
+          @handlers[event] << handler
+        end
+      end
+
+      # Emite evento
+      #
+      # @param event [Symbol] Nome do evento
+      # @param data [Hash] Dados do evento
+      def emit(event, **data)
+        handlers = @mutex.synchronize { @handlers[event]&.dup || [] }
+        
+        handlers.each do |handler|
+          Thread.new { handler.call(data) }
+        end
+      end
+
+      # Remove todos handlers de um evento
+      #
+      # @param event [Symbol] Nome do evento
+      def off(event)
+        @mutex.synchronize { @handlers.delete(event) }
+      end
+    end
+  end
+end

data/lib/gsd/agents/swarm.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'observer'
+
+module Gsd
+  module Agents
+    # AgentSwarm - Orquestração multi-agente avançada
+    #
+    # Gerencia múltiplos agents simultâneos com:
+    # - Spawn/monitoramento de agents
+    # - Roteamento inteligente de tarefas
+    # - Comunicação entre agents
+    # - Execução paralela
+    # - Auto-recovery
+    class Swarm
+      include Observable
+
+      attr_reader :agents, :active_agents, :task_queue, :metrics
+
+      def initialize(max_concurrent: 5, auto_recovery: true)
+        @agents = {}          # Hash de agent_id => agent
+        @active_agents = []  # Lista de agents ativos
+        @task_queue = []     # Fila de tarefas pendentes
+        @max_concurrent = max_concurrent
+        @auto_recovery = auto_recovery
+        @metrics = {
+          tasks_completed: 0,
+          tasks_failed: 0,
+          spawn_count: 0,
+          total_runtime: 0.0
+        }
+        @running = false
+        @mutex = Mutex.new
+      end
+
+      # Inicia o swarm (loop de orquestração)
+      def start
+        @running = true
+        Thread.new { orchestration_loop }
+      end
+
+      # Para o swarm
+      def stop
+        @running = false
+      end
+
+      # Cria um novo agent no swarm
+      #
+      # @param type [Symbol] Tipo do agente (:code, :plan, :debug, etc)
+      # @param config [Hash] Configuração do agente
+      # @return [String] ID do agente criado
+      def spawn(type:, config: {})
+        agent_id = generate_agent_id
+        agent = Agent.new(
+          id: agent_id,
+          type: type,
+          config: config,
+          swarm: self
+        )
+
+        @mutex.synchronize do
+          @agents[agent_id] = agent
+          @active_agents << agent_id
+          @metrics[:spawn_count] += 1
+        end
+
+        # Notifica observadores
+        changed
+        notify_observers(:agent_spawned, agent_id, type)
+
+        agent_id
+      end
+
+      # Encerra um agente específico
+      #
+      # @param agent_id [String] ID do agente
+      def terminate(agent_id)
+        @mutex.synchronize do
+          if agent = @agents.delete(agent_id)
+            @active_agents.delete(agent_id)
+            agent.stop
+          end
+        end
+
+        changed
+        notify_observers(:agent_terminated, agent_id)
+      end
+
+      # Roteia uma tarefa para o agente mais adequado
+      #
+      # @param task [Hash] Descrição da tarefa
+      # @return [String] ID do agente que recebeu a tarefa
+      def route_task(task)
+        router = Router.new(@agents.values)
+        best_agent = router.select_agent_for(task)
+
+        if best_agent
+          best_agent.assign_task(task)
+          changed
+          notify_observers(:task_routed, task, best_agent.id)
+          best_agent.id
+        else
+          # Enfileira se nenhum agente disponível
+          @mutex.synchronize { @task_queue << task }
+          changed
+          notify_observers(:task_queued, task)
+          nil
+        end
+      end
+
+      # Envia mensagem de um agente para outro
+      #
+      # @param from [String] ID do agente remetente
+      # @param to [String] ID do agente destinatário
+      # @param message [Hash] Mensagem
+      def send_message(from:, to:, message:)
+        return unless target = @agents[to]
+
+        envelope = {
+          from: from,
+          to: to,
+          message: message,
+          timestamp: Time.now,
+          id: SecureRandom.uuid
+        }
+
+        target.receive_message(envelope)
+
+        changed
+        notify_observers(:message_sent, envelope)
+      end
+
+      # Broadcast mensagem para todos agents de um tipo
+      #
+      # @param from [String] ID do agente remetente
+      # @param type [Symbol] Tipo de agente destinatário
+      # @param message [Hash] Mensagem
+      def broadcast(from:, type:, message:)
+        targets = @agents.values.select { |a| a.type == type }
+
+        targets.each do |agent|
+          send_message(from: from, to: agent.id, message: message)
+        end
+      end
+
+      # Obtém estatísticas do swarm
+      #
+      # @return [Hash] Métricas atuais
+      def stats
+        @mutex.synchronize do
+          {
+            total_agents: @agents.count,
+            active_agents: @active_agents.count,
+            queued_tasks: @task_queue.count,
+            **@metrics
+          }
+        end
+      end
+
+      # Lista todos agents de um tipo específico
+      #
+      # @param type [Symbol, nil] Tipo de agente (nil = todos)
+      # @return [Array<Agent>] Lista de agents
+      def list(type: nil)
+        agents = @agents.values
+        agents = agents.select { |a| a.type == type } if type
+        agents
+      end
+
+      private
+
+      def generate_agent_id
+        "agent-#{SecureRandom.uuid[0..7]}"
+      end
+
+      def orchestration_loop
+        while @running
+          @mutex.synchronize do
+            # Processa fila de tarefas
+            process_task_queue
+
+            # Monitora agents e faz recovery se necessário
+            monitor_agents if @auto_recovery
+
+            # Atualiza métricas
+            update_metrics
+          end
+
+          sleep(0.5)  # Intervalo de orquestração
+        end
+      end
+
+      def process_task_queue
+        return if @task_queue.empty?
+        return if @active_agents.count >= @max_concurrent
+
+        # Pega próxima tarefa da fila
+        task = @task_queue.shift
+        route_task(task)
+      end
+
+      def monitor_agents
+        @active_agents.each do |agent_id|
+          agent = @agents[agent_id]
+          next unless agent
+
+          if agent.crashed?
+            # Tenta restart
+            changed
+            notify_observers(:agent_crashed, agent_id)
+
+            if @auto_recovery
+              agent.restart
+              changed
+              notify_observers(:agent_restarted, agent_id)
+            else
+              terminate(agent_id)
+            end
+          end
+        end
+      end
+
+      def update_metrics
+        @metrics[:total_runtime] += 0.5
+      end
+    end
+
+    # Agente individual dentro do swarm
+    class Agent
+      attr_reader :id, :type, :config, :state, :task_count
+
+      def initialize(id:, type:, config:, swarm:)
+        @id = id
+        @type = type
+        @config = config
+        @swarm = swarm
+        @state = :idle
+        @task_count = 0
+        @current_task = nil
+        @message_queue = []
+        @mutex = Mutex.new
+      end
+
+      # Atribui uma tarefa ao agente
+      def assign_task(task)
+        @mutex.synchronize do
+          @current_task = task
+          @state = :working
+          @task_count += 1
+        end
+
+        # Executa em thread separada
+        Thread.new { execute_task(task) }
+      end
+
+      # Recebe mensagem de outro agente
+      def receive_message(envelope)
+        @mutex.synchronize do
+          @message_queue << envelope
+        end
+      end
+
+      # Obtém mensagens pendentes
+      def pending_messages
+        @mutex.synchronize do
+          messages = @message_queue.dup
+          @message_queue.clear
+          messages
+        end
+      end
+
+      # Para o agente
+      def stop
+        @mutex.synchronize { @state = :stopped }
+      end
+
+      # Reinicia o agente (recovery)
+      def restart
+        @mutex.synchronize do
+          @state = :idle
+          @current_task = nil
+        end
+      end
+
+      # Verifica se agente crashou
+      def crashed?
+        @state == :crashed
+      end
+
+      # Reporta crash (para ser chamado se algo der errado)
+      def report_crash(error)
+        @mutex.synchronize { @state = :crashed }
+      end
+
+      private
+
+      def execute_task(task)
+        # Implementação simulada - na prática, chamaría o provider de AI
+        sleep(rand(1.0..3.0))  # Simula processamento
+
+        @mutex.synchronize do
+          @state = :idle
+          @current_task = nil
+        end
+
+        # Notifica swarm que terminou
+        @swarm&.changed
+        @swarm&.notify_observers(:task_completed, @id, task)
+      rescue => e
+        report_crash(e)
+      end
+    end
+
+    # Router inteligente para distribuir tarefas
+    class Router
+      def initialize(agents)
+        @agents = agents
+      end
+
+      # Seleciona o melhor agente para uma tarefa
+      def select_agent_for(task)
+        available = @agents.select { |a| a.state == :idle }
+        return nil if available.empty?
+
+        # Roteamento baseado no tipo de tarefa
+        case task[:type]
+        when :code, :programming, :debug
+          available.select { |a| a.type == :code }.first
+        when :plan, :architecture, :design
+          available.select { |a| a.type == :plan }.first
+        when :debug, :error, :fix
+          available.select { |a| a.type == :debug }.first
+        else
+          # Round-robin para tarefas genéricas
+          available.min_by(&:task_count)
+        end
+      end
+    end
+  end
+end