fantasy-cli 1.2.6

data/lib/gsd/tools/registry.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'gsd/tools/base'
+
+module Gsd
+  module Tools
+    # Tools Registry - Registro central de todas as tools
+    #
+    # Responsável por:
+    # - Registrar tools disponíveis
+    # - Buscar tools por nome
+    # - Listar todas as tools
+    # - Filtrar tools por categoria
+    class Registry
+      @tools = {}
+      @categories = {}
+
+      class << self
+        # Registra uma nova tool
+        #
+        # @param name [String] Nome da tool
+        # @param tool_class [Class] Classe da tool
+        # @param category [Symbol] Categoria da tool
+        # @return [void]
+        def register(name, tool_class, category: :general)
+          @tools[name] = tool_class
+          @categories[category] ||= []
+          @categories[category] << name
+        end
+
+        # Busca uma tool por nome
+        #
+        # @param name [String] Nome da tool
+        # @return [Class,nil] Classe da tool ou nil
+        def find(name)
+          @tools[name]
+        end
+
+        # Retorna todas as tools
+        #
+        # @return [Array<Class>] Lista de tools
+        def all
+          @tools.values
+        end
+
+        # Retorna nomes de todas as tools
+        #
+        # @return [Array<String>] Lista de nomes
+        def all_names
+          @tools.keys
+        end
+
+        # Lista tools por categoria
+        #
+        # @param category [Symbol] Categoria
+        # @return [Array<Class>] Tools da categoria
+        def by_category(category)
+          (@categories[category] || []).map { |name| @tools[name] }.compact
+        end
+
+        # Retorna todas as categorias
+        #
+        # @return [Array<Symbol>] Lista de categorias
+        def categories
+          @categories.keys
+        end
+
+        # Verifica se uma tool existe
+        #
+        # @param name [String] Nome da tool
+        # @return [Boolean] true se existe
+        def exist?(name)
+          @tools.key?(name)
+        end
+
+        # Limpa o registry (para testes)
+        #
+        # @return [void]
+        def clear
+          @tools = {}
+          @categories = {}
+        end
+
+        # Exporta tools para formato da API
+        #
+        # @return [Array<Hash>] Tools formatadas
+        def to_api_format
+          @tools.map do |name, tool_class|
+            {
+              type: 'function',
+              function: {
+                name: tool_class.name,
+                description: tool_class.description,
+                parameters: tool_class.input_schema || { type: 'object', properties: {} }
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gsd/tools/task.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'gsd/go/bridge'
+
+module Gsd
+  module Tools
+    # TaskCreateTool - Cria nova tarefa
+    class TaskCreateTool < Base
+      class << self
+        tool_name('task_create')
+        tool_description('Create a new task')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            description: {
+              type: 'string',
+              description: 'Task description'
+            },
+            assignee: {
+              type: 'string',
+              description: 'Task assignee'
+            },
+            priority: {
+              type: 'string',
+              description: 'Priority: low, medium, high',
+              enum: ['low', 'medium', 'high']
+            }
+          },
+          required: ['description']
+        })
+      end
+
+      def execute(args)
+        description = args[:description] || args['description']
+        assignee = args[:assignee] || args['assignee']
+        priority = args[:priority] || args['priority'] || 'medium'
+
+        raise ArgumentError, 'Description is required' unless description
+
+        log_debug("Creating task: #{description}")
+
+        result = Gsd::Go::Bridge.call('task', {
+          'create' => true,
+          'description' => description,
+          'assignee' => assignee,
+          'priority' => priority
+        }, cwd: @cwd)
+
+        parse_result(result, 'create')
+      rescue => e
+        error_result(e, 'create')
+      end
+
+      def self.safe?(args); false; end
+      def self.read_only?(args); false; end
+      def self.destructive?(args); false; end
+    end
+
+    # TaskListTool - Lista tarefas
+    class TaskListTool < Base
+      class << self
+        tool_name('task_list')
+        tool_description('List all tasks')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            status: {
+              type: 'string',
+              description: 'Filter by status: pending, running, completed',
+              enum: ['pending', 'running', 'completed']
+            },
+            assignee: {
+              type: 'string',
+              description: 'Filter by assignee'
+            }
+          }
+        })
+      end
+
+      def execute(args)
+        status = args[:status] || args['status']
+        assignee = args[:assignee] || args['assignee']
+
+        log_debug("Listing tasks")
+
+        params = { 'list' => true }
+        params['status'] = status if status
+        params['assignee'] = assignee if assignee
+
+        result = Gsd::Go::Bridge.call('task', params, cwd: @cwd)
+
+        parse_result(result, 'list')
+      rescue => e
+        error_result(e, 'list')
+      end
+
+      def self.safe?(args); true; end
+      def self.read_only?(args); true; end
+    end
+
+    # TaskUpdateTool - Atualiza tarefa
+    class TaskUpdateTool < Base
+      class << self
+        tool_name('task_update')
+        tool_description('Update an existing task')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            task_id: {
+              type: 'string',
+              description: 'Task ID'
+            },
+            status: {
+              type: 'string',
+              description: 'New status',
+              enum: ['pending', 'running', 'completed']
+            },
+            description: {
+              type: 'string',
+              description: 'New description'
+            },
+            assignee: {
+              type: 'string',
+              description: 'New assignee'
+            }
+          },
+          required: ['task_id']
+        })
+      end
+
+      def execute(args)
+        task_id = args[:task_id] || args['task_id']
+        status = args[:status] || args['status']
+        description = args[:description] || args['description']
+        assignee = args[:assignee] || args['assignee']
+
+        raise ArgumentError, 'Task ID is required' unless task_id
+
+        log_debug("Updating task: #{task_id}")
+
+        params = { 'update' => true, 'task_id' => task_id }
+        params['status'] = status if status
+        params['description'] = description if description
+        params['assignee'] = assignee if assignee
+
+        result = Gsd::Go::Bridge.call('task', params, cwd: @cwd)
+
+        parse_result(result, 'update')
+      rescue => e
+        error_result(e, 'update')
+      end
+
+      def self.safe?(args); false; end
+      def self.read_only?(args); false; end
+      def self.destructive?(args); false; end
+    end
+
+    # TaskStopTool - Para tarefa
+    class TaskStopTool < Base
+      class << self
+        tool_name('task_stop')
+        tool_description('Stop a running task')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            task_id: {
+              type: 'string',
+              description: 'Task ID to stop'
+            }
+          },
+          required: ['task_id']
+        })
+      end
+
+      def execute(args)
+        task_id = args[:task_id] || args['task_id']
+
+        raise ArgumentError, 'Task ID is required' unless task_id
+
+        log_debug("Stopping task: #{task_id}")
+
+        result = Gsd::Go::Bridge.call('task', {
+          'stop' => true,
+          'task_id' => task_id
+        }, cwd: @cwd)
+
+        parse_result(result, 'stop')
+      rescue => e
+        error_result(e, 'stop')
+      end
+
+      def self.safe?(args); false; end
+      def self.read_only?(args); false; end
+      def self.destructive?(args); true; end
+    end
+
+    # Helper methods
+    module TaskHelpers
+      def parse_result(result, operation)
+        if result['success']
+          {
+            success: true,
+            operation: operation,
+            data: result['data'],
+            cwd: @cwd
+          }
+        else
+          {
+            success: false,
+            error: result['error'] || 'unknown_error',
+            message: result['message'],
+            operation: operation
+          }
+        end
+      end
+
+      def error_result(error, operation)
+        log_debug("Error: #{error.message}")
+        {
+          success: false,
+          error: 'bridge_error',
+          message: error.message,
+          operation: operation
+        }
+      end
+    end
+  end
+end
+
+# Registra as tools
+Gsd::Tools::Registry.register('task_create', Gsd::Tools::TaskCreateTool, category: :tasks)
+Gsd::Tools::Registry.register('task_list', Gsd::Tools::TaskListTool, category: :tasks)
+Gsd::Tools::Registry.register('task_update', Gsd::Tools::TaskUpdateTool, category: :tasks)
+Gsd::Tools::Registry.register('task_stop', Gsd::Tools::TaskStopTool, category: :tasks)

data/lib/gsd/tools/todo_write.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'json'
+require 'fileutils'
+
+module Gsd
+  module Tools
+    # TodoWriteTool - Gerencia lista de tarefas (TODOs)
+    #
+    # Uso:
+    #   tool = TodoWriteTool.new(cwd: '/path')
+    #   result = tool.execute(operation: 'add', todo: 'Implement feature')
+    class TodoWriteTool < Base
+      class << self
+        tool_name('todo_write')
+        tool_description('Manage TODO list: add, remove, update, list tasks')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            operation: {
+              type: 'string',
+              description: 'Operation: add, remove, update, list, complete',
+              enum: ['add', 'remove', 'update', 'list', 'complete']
+            },
+            todo: {
+              type: 'string',
+              description: 'TODO text (for add/update operations)'
+            },
+            id: {
+              type: 'integer',
+              description: 'TODO ID (for remove/update/complete operations)'
+            },
+            priority: {
+              type: 'string',
+              description: 'Priority level: low, medium, high',
+              enum: ['low', 'medium', 'high'],
+              default: 'medium'
+            },
+            tags: {
+              type: 'array',
+              description: 'Tags for the TODO',
+              items: {
+                type: 'string'
+              }
+            },
+            file: {
+              type: 'string',
+              description: 'TODO file path (default: .planning/todos/todos.json)',
+              default: '.planning/todos/todos.json'
+            }
+          },
+          required: ['operation']
+        })
+      end
+
+      # Gerencia lista de TODOs
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da operação
+      def execute(args)
+        operation = args[:operation] || args['operation']
+        todo_text = args[:todo] || args['todo']
+        todo_id = args[:id] || args['id']
+        priority = args[:priority] || args['priority'] || 'medium'
+        tags = args[:tags] || args['tags'] || []
+        file_path = args[:file] || args['file'] || '.planning/todos/todos.json'
+
+        raise ArgumentError, 'Operation is required' unless operation
+
+        log_debug("Operation: #{operation}")
+
+        # Normaliza path
+        full_path = File.expand_path(file_path, @cwd)
+
+        # Carrega TODOs existentes
+        todos = load_todos(full_path)
+
+        # Executa operação
+        result = case operation
+                 when 'add'
+                   add_todo(todos, todo_text, priority, tags)
+                 when 'remove'
+                   remove_todo(todos, todo_id)
+                 when 'update'
+                   update_todo(todos, todo_id, todo_text, priority, tags)
+                 when 'complete'
+                   complete_todo(todos, todo_id)
+                 when 'list'
+                   list_todos(todos)
+                 else
+                   { success: false, error: 'invalid_operation', message: "Unknown operation: #{operation}" }
+                 end
+
+        # Salva se modificou
+        if result[:success] && ['add', 'remove', 'update', 'complete'].include?(operation)
+          save_todos(full_path, todos)
+          result[:todos] = todos
+          result[:file] = full_path
+        elsif result[:success] && operation == 'list'
+          result[:todos] = todos
+        end
+
+        result
+      end
+
+      # Verifica se é safe
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.safe?(args)
+        true
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true apenas para list
+      def self.read_only?(args)
+        operation = args[:operation] || args['operation']
+        operation == 'list'
+      end
+
+      private
+
+      # Carrega TODOs do arquivo
+      #
+      # @param path [String] Caminho do arquivo
+      # @return [Array] Lista de TODOs
+      def load_todos(path)
+        return [] unless File.exist?(path)
+
+        data = JSON.parse(File.read(path))
+        data['todos'] || []
+      rescue => e
+        log_debug("Error loading todos: #{e.message}")
+        []
+      end
+
+      # Salva TODOs no arquivo
+      #
+      # @param path [String] Caminho do arquivo
+      # @param todos [Array] Lista de TODOs
+      # @return [void]
+      def save_todos(path, todos)
+        # Cria diretório se necessário
+        FileUtils.mkdir_p(File.dirname(path))
+
+        data = {
+          todos: todos,
+          updated_at: Time.now.iso8601
+        }
+
+        File.write(path, JSON.pretty_generate(data))
+        log_debug("Todos saved to: #{path}")
+      end
+
+      # Adiciona TODO
+      #
+      # @param todos [Array] Lista de TODOs
+      # @param text [String] Texto do TODO
+      # @param priority [String] Prioridade
+      # @param tags [Array] Tags
+      # @return [Hash] Resultado
+      def add_todo(todos, text, priority, tags)
+        return { success: false, error: 'missing_todo', message: 'TODO text is required' } unless text
+
+        new_todo = {
+          id: next_id(todos),
+          text: text,
+          status: 'pending',
+          priority: priority,
+          tags: tags,
+          created_at: Time.now.iso8601,
+          updated_at: Time.now.iso8601
+        }
+
+        todos << new_todo
+
+        {
+          success: true,
+          message: 'TODO added successfully',
+          todo: new_todo,
+          total: todos.count
+        }
+      end
+
+      # Remove TODO
+      #
+      # @param todos [Array] Lista de TODOs
+      # @param id [Integer] ID do TODO
+      # @return [Hash] Resultado
+      def remove_todo(todos, id)
+        return { success: false, error: 'missing_id', message: 'TODO ID is required' } unless id
+
+        todo = todos.find { |t| t['id'] == id }
+        return { success: false, error: 'not_found', message: "TODO not found: #{id}" } unless todo
+
+        todos.delete(todo)
+
+        {
+          success: true,
+          message: 'TODO removed successfully',
+          removed: todo,
+          total: todos.count
+        }
+      end
+
+      # Atualiza TODO
+      #
+      # @param todos [Array] Lista de TODOs
+      # @param id [Integer] ID do TODO
+      # @param text [String] Novo texto
+      # @param priority [String] Nova prioridade
+      # @param tags [Array] Novas tags
+      # @return [Hash] Resultado
+      def update_todo(todos, id, text, priority, tags)
+        return { success: false, error: 'missing_id', message: 'TODO ID is required' } unless id
+
+        todo = todos.find { |t| t['id'] == id }
+        return { success: false, error: 'not_found', message: "TODO not found: #{id}" } unless todo
+
+        todo['text'] = text if text
+        todo['priority'] = priority if priority
+        todo['tags'] = tags if tags
+        todo['updated_at'] = Time.now.iso8601
+
+        {
+          success: true,
+          message: 'TODO updated successfully',
+          todo: todo,
+          total: todos.count
+        }
+      end
+
+      # Completa TODO
+      #
+      # @param todos [Array] Lista de TODOs
+      # @param id [Integer] ID do TODO
+      # @return [Hash] Resultado
+      def complete_todo(todos, id)
+        return { success: false, error: 'missing_id', message: 'TODO ID is required' } unless id
+
+        todo = todos.find { |t| t['id'] == id }
+        return { success: false, error: 'not_found', message: "TODO not found: #{id}" } unless todo
+
+        todo['status'] = 'completed'
+        todo['completed_at'] = Time.now.iso8601
+        todo['updated_at'] = Time.now.iso8601
+
+        {
+          success: true,
+          message: 'TODO completed successfully',
+          todo: todo,
+          total: todos.count
+        }
+      end
+
+      # Lista TODOs
+      #
+      # @param todos [Array] Lista de TODOs
+      # @return [Hash] Resultado
+      def list_todos(todos)
+        pending = todos.select { |t| t['status'] == 'pending' }
+        completed = todos.select { |t| t['status'] == 'completed' }
+
+        {
+          success: true,
+          total: todos.count,
+          pending_count: pending.count,
+          completed_count: completed.count,
+          pending: pending,
+          completed: completed
+        }
+      end
+
+      # Próximo ID disponível
+      #
+      # @param todos [Array] Lista de TODOs
+      # @return [Integer] Próximo ID
+      def next_id(todos)
+        max_id = todos.map { |t| t['id'] }.max || 0
+        max_id + 1
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('todo_write', Gsd::Tools::TodoWriteTool, category: :tasks)