fantasy-cli 1.2.6

data/lib/gsd/agents/task_manager.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Gsd
+  module Agents
+    # Task Manager - Gerenciamento de tarefas
+    #
+    # Responsável por:
+    # - Criar tarefas
+    # - Atribuir tarefas a workers
+    # - Monitorar progresso
+    # - Agregar resultados
+    class TaskManager
+      attr_reader :tasks, :assignments
+
+      # Inicializa o Task Manager
+      def initialize
+        @tasks = {}
+        @assignments = {}
+      end
+
+      # Cria tarefa
+      #
+      # @param description [String] Descrição
+      # @param priority [Integer] Prioridade (1-10)
+      # @return [Hash] Tarefa criada
+      def create_task(description, priority: 5)
+        task_id = "task-#{SecureRandom.uuid[0..8]}"
+
+        task = {
+          id: task_id,
+          description: description,
+          priority: priority,
+          status: :pending,
+          assigned_to: nil,
+          created_at: Time.now,
+          started_at: nil,
+          completed_at: nil,
+          results: nil
+        }
+
+        @tasks[task_id] = task
+        task
+      end
+
+      # Atribui tarefa a worker
+      #
+      # @param task_id [String] ID da tarefa
+      # @param worker_id [String] ID do worker
+      # @return [Boolean] true se sucesso
+      def assign_task(task_id, worker_id)
+        task = @tasks[task_id]
+        return false unless task
+
+        task[:assigned_to] = worker_id
+        task[:status] = :assigned
+
+        @assignments[worker_id] ||= []
+        @assignments[worker_id] << task_id
+
+        true
+      end
+
+      # Inicia tarefa
+      #
+      # @param task_id [String] ID da tarefa
+      # @return [void]
+      def start_task(task_id)
+        task = @tasks[task_id]
+        return unless task
+
+        task[:status] = :running
+        task[:started_at] = Time.now
+      end
+
+      # Completa tarefa
+      #
+      # @param task_id [String] ID da tarefa
+      # @param results [Hash] Resultados
+      # @return [void]
+      def complete_task(task_id, results)
+        task = @tasks[task_id]
+        return unless task
+
+        task[:status] = :completed
+        task[:completed_at] = Time.now
+        task[:results] = results
+      end
+
+      # Falha na tarefa
+      #
+      # @param task_id [String] ID da tarefa
+      # @param error [String] Erro
+      # @return [void]
+      def fail_task(task_id, error)
+        task = @tasks[task_id]
+        return unless task
+
+        task[:status] = :failed
+        task[:completed_at] = Time.now
+        task[:error] = error
+      end
+
+      # Obtém tarefa
+      #
+      # @param task_id [String] ID da tarefa
+      # @return [Hash, nil] Tarefa
+      def get_task(task_id)
+        @tasks[task_id]
+      end
+
+      # Lista tarefas
+      #
+      # @param status [Symbol, nil] Filtrar por status
+      # @return [Array<Hash>] Lista de tarefas
+      def list_tasks(status: nil)
+        if status
+          @tasks.values.select { |t| t[:status] == status }
+        else
+          @tasks.values
+        end
+      end
+
+      # Tarefas de um worker
+      #
+      # @param worker_id [String] ID do worker
+      # @return [Array<String>] IDs das tarefas
+      def worker_tasks(worker_id)
+        @assignments[worker_id] || []
+      end
+
+      # Progresso das tarefas
+      #
+      # @return [Hash] Progresso
+      def progress
+        total = @tasks.count
+        return { total: 0 } if total == 0
+
+        {
+          total: total,
+          pending: @tasks.count { |_, t| t[:status] == :pending },
+          running: @tasks.count { |_, t| t[:status] == :running },
+          completed: @tasks.count { |_, t| t[:status] == :completed },
+          failed: @tasks.count { |_, t| t[:status] == :failed },
+          percent_complete: (@tasks.count { |_, t| t[:status] == :completed }.to_f / total * 100).round(2)
+        }
+      end
+
+      # Limpa tarefas completadas
+      #
+      # @return [Integer] Número de tarefas limpas
+      def cleanup
+        completed = @tasks.select { |_, t| t[:status] == :completed }
+        completed.each_key { |id| @tasks.delete(id) }
+        completed.count
+      end
+    end
+  end
+end

data/lib/gsd/agents/worker.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Gsd
+  module Agents
+    # Worker - Agente worker base
+    #
+    # Responsável por:
+    # - Executar tarefas
+    # - Reportar resultados
+    # - Gerenciar estado
+    class Worker
+      attr_reader :id, :type, :prompt, :status
+
+      # Status possíveis
+      STATUSES = [:pending, :running, :completed, :failed, :stopped].freeze
+
+      # Inicializa o Worker
+      #
+      # @param id [String] ID único
+      # @param type [Symbol] Tipo do agente
+      # @param prompt [String] Prompt inicial
+      # @param timeout [Integer] Timeout em segundos
+      def initialize(id:, type:, prompt:, timeout: 300, **options)
+        @id = id
+        @type = type
+        @prompt = prompt
+        @timeout = timeout
+        @status = :pending
+        @results = nil
+        @error = nil
+        @started_at = nil
+        @completed_at = nil
+        @messages = []
+        @options = options
+      end
+
+      # Executa o worker
+      #
+      # @return [Hash] Resultados
+      def execute
+        @status = :running
+        @started_at = Time.now
+
+        begin
+          Timeout.timeout(@timeout) do
+            @results = run_task
+          end
+          @status = :completed
+        rescue Timeout::Error => e
+          @status = :failed
+          @error = "Timeout after #{@timeout}s"
+        rescue => e
+          @status = :failed
+          @error = e.message
+        ensure
+          @completed_at = Time.now
+        end
+
+        @results
+      end
+
+      # Continua execução com nova mensagem
+      #
+      # @param message [String] Mensagem
+      # @return [void]
+      def continue(message)
+        @messages << {
+          role: :user,
+          content: message,
+          timestamp: Time.now
+        }
+
+        # Re-executa se completado
+        execute if @status == :completed
+      end
+
+      # Para o worker
+      #
+      # @return [void]
+      def stop
+        @status = :stopped
+        @completed_at = Time.now
+      end
+
+      # Aguarda conclusão
+      #
+      # @param timeout [Integer] Timeout
+      # @return [void]
+      def wait(timeout: nil)
+        # Implementação simplificada
+        sleep(0.1) while @status == :running || @status == :pending
+      end
+
+      # Verifica se está ativo
+      #
+      # @return [Boolean] true se ativo
+      def active?
+        [:pending, :running].include?(@status)
+      end
+
+      # Verifica se completou
+      #
+      # @return [Boolean] true se completado
+      def completed?
+        @status == :completed
+      end
+
+      # Verifica se falhou
+      #
+      # @return [Boolean] true se falhou
+      def failed?
+        @status == :failed
+      end
+
+      # Retorna resultados
+      #
+      # @return [Hash, nil] Resultados
+      def results
+        @results
+      end
+
+      # Retorna erro
+      #
+      # @return [String, nil] Erro
+      def error
+        @error
+      end
+
+      # Retorna status completo
+      #
+      # @return [Hash] Status
+      def status
+        {
+          id: @id,
+          type: @type,
+          status: @status,
+          prompt: @prompt[0..100] + '...',
+          started_at: @started_at,
+          completed_at: @completed_at,
+          has_results: !@results.nil?,
+          has_error: !@error.nil?
+        }
+      end
+
+      private
+
+      # Executa tarefa
+      #
+      # @return [Hash] Resultados
+      def run_task
+        # Implementação base - subclasses devem sobrescrever
+        {
+          content: "Worker #{@id} executed task: #{@prompt}",
+          type: @type,
+          duration: Time.now - @started_at
+        }
+      end
+    end
+  end
+end

data/lib/gsd/agents.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# GSD Agents Module
+#
+# Sistema multi-agent para GSD Tools
+#
+# Uso:
+#   require 'gsd/agents'
+#
+#   # Criar coordinator
+#   coordinator = Gsd::Agents::Coordinator.new
+#
+#   # Spawn worker
+#   worker = coordinator.spawn(type: :worker, prompt: "Investigate bug")
+#
+#   # Aguardar conclusão
+#   coordinator.wait_all
+#
+#   # Obter resultados
+#   results = coordinator.get_results(worker.id)
+
+module Gsd
+  module Agents
+  end
+end
+
+# Load agent files
+require 'gsd/agents/coordinator'
+require 'gsd/agents/worker'
+require 'gsd/agents/task_manager'