fantasy-cli 1.2.6

data/lib/gsd/tools/gsd_phase.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'gsd/go/bridge'
+
+module Gsd
+  module Tools
+    # GsdPhaseTool - Operações de Phases via Go bridge
+    #
+    # Uso:
+    #   tool = GsdPhaseTool.new(cwd: '/path')
+    #   result = tool.execute(operation: 'find', phase: '1')
+    class GsdPhaseTool < Base
+      class << self
+        tool_name('gsd_phase')
+        tool_description('GSD Phase operations: find, list, next-decimal, add')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            operation: {
+              type: 'string',
+              description: 'Operation: find, list, next_decimal, add',
+              enum: ['find', 'list', 'next_decimal', 'add']
+            },
+            phase: {
+              type: 'string',
+              description: 'Phase number (for find/next_decimal operations)'
+            },
+            description: {
+              type: 'string',
+              description: 'Phase description (for add operation)'
+            },
+            id: {
+              type: 'string',
+              description: 'Phase ID (for add operation)'
+            }
+          },
+          required: ['operation']
+        })
+      end
+
+      # Executa operação de Phase
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da operação
+      def execute(args)
+        operation = args[:operation] || args['operation']
+        phase = args[:phase] || args['phase']
+        description = args[:description] || args['description']
+        phase_id = args[:id] || args['id']
+
+        raise ArgumentError, 'Operation is required' unless operation
+
+        log_debug("Phase operation: #{operation}")
+
+        # Chama Go bridge
+        result = case operation
+                 when 'find'
+                   raise ArgumentError, 'Phase number required' unless phase
+                   Gsd::Go::Bridge.call('phase', {
+                     'find' => true,
+                     'phase' => phase
+                   }, cwd: @cwd)
+                 when 'list'
+                   Gsd::Go::Bridge.call('phase', { 'list' => true }, cwd: @cwd)
+                 when 'next_decimal'
+                   raise ArgumentError, 'Phase number required' unless phase
+                   Gsd::Go::Bridge.call('phase', {
+                     'next_decimal' => true,
+                     'phase' => phase
+                   }, cwd: @cwd)
+                 when 'add'
+                   raise ArgumentError, 'Description required for add' unless description
+                   params = {
+                     'add' => true,
+                     'description' => description
+                   }
+                   params['id'] = phase_id if phase_id
+                   Gsd::Go::Bridge.call('phase', params, cwd: @cwd)
+                 else
+                   { 'success' => false, 'error' => "Invalid operation: #{operation}" }
+                 end
+
+        # Parseia resultado
+        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
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          success: false,
+          error: 'bridge_error',
+          message: e.message,
+          operation: operation
+        }
+      end
+
+      # Verifica se é safe
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true apenas para find/list
+      def self.safe?(args)
+        operation = args[:operation] || args['operation']
+        ['find', 'list'].include?(operation)
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true apenas para find/list
+      def self.read_only?(args)
+        safe?(args)
+      end
+
+      # Verifica se é destrutivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true para add
+      def self.destructive?(args)
+        operation = args[:operation] || args['operation']
+        operation == 'add'
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('gsd_phase', Gsd::Tools::GsdPhaseTool, category: :gsd)

data/lib/gsd/tools/gsd_roadmap.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'gsd/go/bridge'
+
+module Gsd
+  module Tools
+    # GsdRoadmapTool - Operações de ROADMAP.md via Go bridge
+    #
+    # Uso:
+    #   tool = GsdRoadmapTool.new(cwd: '/path')
+    #   result = tool.execute(operation: 'analyze')
+    class GsdRoadmapTool < Base
+      class << self
+        tool_name('gsd_roadmap')
+        tool_description('GSD Roadmap operations: get-phase, analyze')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            operation: {
+              type: 'string',
+              description: 'Operation: get-phase, analyze',
+              enum: ['get-phase', 'analyze']
+            },
+            phase: {
+              type: 'string',
+              description: 'Phase number (for get-phase operation)'
+            }
+          },
+          required: ['operation']
+        })
+      end
+
+      # Executa operação de Roadmap
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da operação
+      def execute(args)
+        operation = args[:operation] || args['operation']
+        phase = args[:phase] || args['phase']
+
+        raise ArgumentError, 'Operation is required' unless operation
+
+        log_debug("Roadmap operation: #{operation}")
+
+        # Chama Go bridge
+        result = case operation
+                 when 'get-phase'
+                   raise ArgumentError, 'Phase number required' unless phase
+                   Gsd::Go::Bridge.call('roadmap', {
+                     'get-phase' => true,
+                     'phase' => phase
+                   }, cwd: @cwd)
+                 when 'analyze'
+                   Gsd::Go::Bridge.call('roadmap', {
+                     'analyze' => true
+                   }, cwd: @cwd)
+                 else
+                   { 'success' => false, 'error' => "Invalid operation: #{operation}" }
+                 end
+
+        # Parseia resultado
+        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
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          success: false,
+          error: 'bridge_error',
+          message: e.message,
+          operation: operation
+        }
+      end
+
+      # Verifica se é safe
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true (apenas leitura)
+      def self.safe?(args)
+        true
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.read_only?(args)
+        true
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('gsd_roadmap', Gsd::Tools::GsdRoadmapTool, category: :gsd)

data/lib/gsd/tools/gsd_state.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'gsd/go/bridge'
+
+module Gsd
+  module Tools
+    # GsdStateTool - Operações de STATE.md via Go bridge
+    #
+    # Uso:
+    #   tool = GsdStateTool.new(cwd: '/path')
+    #   result = tool.execute(operation: 'json')
+    class GsdStateTool < Base
+      class << self
+        tool_name('gsd_state')
+        tool_description('GSD State operations: load, json, update, patch, get')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            operation: {
+              type: 'string',
+              description: 'Operation: load, json, update, patch, get',
+              enum: ['load', 'json', 'update', 'patch', 'get']
+            },
+            field: {
+              type: 'string',
+              description: 'Field name (for update/patch operations)'
+            },
+            value: {
+              type: 'string',
+              description: 'Field value (for update/patch operations)'
+            },
+            fields: {
+              type: 'object',
+              description: 'Multiple fields (for patch operation)'
+            },
+            section: {
+              type: 'string',
+              description: 'Section name (for get operation)'
+            }
+          },
+          required: ['operation']
+        })
+      end
+
+      # Executa operação de State
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da operação
+      def execute(args)
+        operation = args[:operation] || args['operation']
+        field = args[:field] || args['field']
+        value = args[:value] || args['value']
+        fields = args[:fields] || args['fields']
+        section = args[:section] || args['section']
+
+        raise ArgumentError, 'Operation is required' unless operation
+
+        log_debug("State operation: #{operation}")
+
+        # Chama Go bridge
+        result = case operation
+                 when 'load', 'json'
+                   Gsd::Go::Bridge.call('state', { 'json' => true }, cwd: @cwd)
+                 when 'update'
+                   raise ArgumentError, 'Field and value required for update' unless field && value
+                   Gsd::Go::Bridge.call('state', {
+                     'update' => true,
+                     'field' => field,
+                     'value' => value
+                   }, cwd: @cwd)
+                 when 'patch'
+                   raise ArgumentError, 'Fields required for patch' unless fields
+                   Gsd::Go::Bridge.call('state', {
+                     'patch' => true,
+                     'fields' => fields
+                   }, cwd: @cwd)
+                 when 'get'
+                   Gsd::Go::Bridge.call('state', {
+                     'get' => true,
+                     'section' => section
+                   }, cwd: @cwd)
+                 else
+                   { 'success' => false, 'error' => "Invalid operation: #{operation}" }
+                 end
+
+        # Parseia resultado
+        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
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          success: false,
+          error: 'bridge_error',
+          message: e.message,
+          operation: operation
+        }
+      end
+
+      # Verifica se é safe
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true apenas para load/json/get
+      def self.safe?(args)
+        operation = args[:operation] || args['operation']
+        ['load', 'json', 'get'].include?(operation)
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true apenas para load/json/get
+      def self.read_only?(args)
+        safe?(args)
+      end
+
+      # Verifica se é destrutivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true para update/patch
+      def self.destructive?(args)
+        operation = args[:operation] || args['operation']
+        ['update', 'patch'].include?(operation)
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('gsd_state', Gsd::Tools::GsdStateTool, category: :gsd)

data/lib/gsd/tools/gsd_template.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'gsd/go/bridge'
+
+module Gsd
+  module Tools
+    # GsdTemplateTool - Preenchimento de templates via Go bridge
+    #
+    # Uso:
+    #   tool = GsdTemplateTool.new(cwd: '/path')
+    #   result = tool.execute(operation: 'fill', type: 'summary', phase: '1')
+    class GsdTemplateTool < Base
+      class << self
+        tool_name('gsd_template')
+        tool_description('GSD Template operations: fill summary, plan, verification, context')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            operation: {
+              type: 'string',
+              description: 'Operation: fill',
+              enum: ['fill']
+            },
+            type: {
+              type: 'string',
+              description: 'Template type: summary, plan, verification, context',
+              enum: ['summary', 'plan', 'verification', 'context']
+            },
+            phase: {
+              type: 'string',
+              description: 'Phase number'
+            },
+            plan: {
+              type: 'string',
+              description: 'Plan number (for plan template)'
+            },
+            name: {
+              type: 'string',
+              description: 'Template name'
+            },
+            template_type: {
+              type: 'string',
+              description: 'Plan type: execute, tdd (for plan template)'
+            }
+          },
+          required: ['operation', 'type', 'phase']
+        })
+      end
+
+      # Executa operação de Template
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da operação
+      def execute(args)
+        operation = args[:operation] || args['operation']
+        template_type = args[:type] || args['type']
+        phase = args[:phase] || args['phase']
+        plan = args[:plan] || args['plan']
+        name = args[:name] || args['name']
+        plan_type = args[:template_type] || args['template_type']
+
+        raise ArgumentError, 'Operation is required' unless operation
+        raise ArgumentError, 'Type is required' unless template_type
+        raise ArgumentError, 'Phase is required' unless phase
+
+        log_debug("Template operation: #{operation}, type: #{template_type}")
+
+        # Chama Go bridge
+        result = case operation
+                 when 'fill'
+                   params = build_fill_params(template_type, phase, plan, name, plan_type)
+                   Gsd::Go::Bridge.call('template', params, cwd: @cwd)
+                 else
+                   { 'success' => false, 'error' => "Invalid operation: #{operation}" }
+                 end
+
+        # Parseia resultado
+        if result['success']
+          {
+            success: true,
+            operation: operation,
+            type: template_type,
+            data: result['data'],
+            cwd: @cwd
+          }
+        else
+          {
+            success: false,
+            error: result['error'] || 'unknown_error',
+            message: result['message'],
+            operation: operation
+          }
+        end
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          success: false,
+          error: 'bridge_error',
+          message: e.message,
+          operation: operation
+        }
+      end
+
+      # Verifica se é safe
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] false (cria arquivos)
+      def self.safe?(args)
+        false
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] false
+      def self.read_only?(args)
+        false
+      end
+
+      # Verifica se é destrutivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] false (cria novos arquivos)
+      def self.destructive?(args)
+        false
+      end
+
+      private
+
+      # Constrói params para operação fill
+      #
+      # @param type [String] Tipo de template
+      # @param phase [String] Número da phase
+      # @param plan [String] Número do plan
+      # @param name [String] Nome
+      # @param plan_type [String] Tipo do plan
+      # @return [Hash] Params
+      def build_fill_params(type, phase, plan, name, plan_type)
+        params = {
+          'fill' => true,
+          'type' => type,
+          'phase' => phase
+        }
+
+        params['plan'] = plan if plan
+        params['name'] = name if name
+        params['template_type'] = plan_type if plan_type
+
+        params
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('gsd_template', Gsd::Tools::GsdTemplateTool, category: :gsd)

data/lib/gsd/tools/gsd_verify.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'gsd/go/bridge'
+
+module Gsd
+  module Tools
+    # GsdVerifyTool - Operações de verificação via Go bridge
+    #
+    # Uso:
+    #   tool = GsdVerifyTool.new(cwd: '/path')
+    #   result = tool.execute(operation: 'plan-structure', file: 'PLAN.md')
+    class GsdVerifyTool < Base
+      class << self
+        tool_name('gsd_verify')
+        tool_description('GSD Verify operations: plan-structure, phase-completeness, references, commits, artifacts, key-links, tasks, summary')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            operation: {
+              type: 'string',
+              description: 'Operation: plan-structure, phase-completeness, references, commits, artifacts, key-links, tasks, summary',
+              enum: ['plan-structure', 'phase-completeness', 'references', 'commits', 'artifacts', 'key-links', 'tasks', 'summary']
+            },
+            file: {
+              type: 'string',
+              description: 'File path (for file-based operations)'
+            },
+            phase: {
+              type: 'string',
+              description: 'Phase number (for phase-completeness)'
+            },
+            commits: {
+              type: 'array',
+              description: 'Commit hashes (for commits operation)',
+              items: {
+                type: 'string'
+              }
+            }
+          },
+          required: ['operation']
+        })
+      end
+
+      # Executa operação de Verify
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da verificação
+      def execute(args)
+        operation = args[:operation] || args['operation']
+        file = args[:file] || args['file']
+        phase = args[:phase] || args['phase']
+        commits = args[:commits] || args['commits']
+
+        raise ArgumentError, 'Operation is required' unless operation
+
+        log_debug("Verify operation: #{operation}")
+
+        # Chama Go bridge
+        result = case operation
+                 when 'plan-structure'
+                   raise ArgumentError, 'File required' unless file
+                   Gsd::Go::Bridge.call('verify', {
+                     'plan-structure' => true,
+                     'file' => file
+                   }, cwd: @cwd)
+                 when 'phase-completeness'
+                   raise ArgumentError, 'Phase required' unless phase
+                   Gsd::Go::Bridge.call('verify', {
+                     'phase-completeness' => true,
+                     'phase' => phase
+                   }, cwd: @cwd)
+                 when 'references'
+                   raise ArgumentError, 'File required' unless file
+                   Gsd::Go::Bridge.call('verify', {
+                     'references' => true,
+                     'file' => file
+                   }, cwd: @cwd)
+                 when 'commits'
+                   raise ArgumentError, 'Commits required' unless commits && commits.any?
+                   Gsd::Go::Bridge.call('verify', {
+                     'commits' => true,
+                     'commits' => commits
+                   }, cwd: @cwd)
+                 when 'artifacts'
+                   raise ArgumentError, 'File required' unless file
+                   Gsd::Go::Bridge.call('verify', {
+                     'artifacts' => true,
+                     'file' => file
+                   }, cwd: @cwd)
+                 when 'key-links'
+                   raise ArgumentError, 'File required' unless file
+                   Gsd::Go::Bridge.call('verify', {
+                     'key-links' => true,
+                     'file' => file
+                   }, cwd: @cwd)
+                 when 'tasks'
+                   raise ArgumentError, 'File required' unless file
+                   Gsd::Go::Bridge.call('verify', {
+                     'tasks' => true,
+                     'file' => file
+                   }, cwd: @cwd)
+                 when 'summary'
+                   raise ArgumentError, 'File required' unless file
+                   Gsd::Go::Bridge.call('verify', {
+                     'summary' => true,
+                     'file' => file
+                   }, cwd: @cwd)
+                 else
+                   { 'success' => false, 'error' => "Invalid operation: #{operation}" }
+                 end
+
+        # Parseia resultado
+        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
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          success: false,
+          error: 'bridge_error',
+          message: e.message,
+          operation: operation
+        }
+      end
+
+      # Verifica se é safe
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true (apenas leitura)
+      def self.safe?(args)
+        true
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.read_only?(args)
+        true
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('gsd_verify', Gsd::Tools::GsdVerifyTool, category: :gsd)