fantasy-cli 1.2.6

data/lib/gsd/history.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # History - Wrapper Ruby para operações de history via Go
+  module History
+    class << self
+      # Agrega todos os SUMMARY.md e cria um digest
+      #
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Digest de history
+      def digest(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('history', { 'digest' => true }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise HistoryError, result['error']
+        end
+      end
+
+      # Extrai dados de um SUMMARY.md específico
+      #
+      # @param file [String] Caminho para o arquivo SUMMARY.md
+      # @param fields [Array<String>] Campos para extrair
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Dados extraídos
+      def summary_extract(file:, fields: [], cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'summary-extract' => file }
+        args['fields'] = fields.join(',') unless fields.empty?
+        result = Go::Bridge.call('history', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise HistoryError, result['error']
+        end
+      end
+
+      # Adiciona uma decisão ao STATE.md
+      #
+      # @param summary [String] Resumo da decisão
+      # @param rationale [String] Racional da decisão
+      # @param phase [String] Phase relacionada
+      # @param cwd [String] Diretório de trabalho
+      def add_decision(summary:, rationale:, phase: nil, cwd: nil)
+        # Note: This would need a Go implementation
+        # For now, just a placeholder
+        raise NotImplementedError, 'add_decision not yet implemented'
+      end
+
+      # Adiciona um blocker ao STATE.md
+      #
+      # @param text [String] Texto do blocker
+      # @param cwd [String] Diretório de trabalho
+      def add_blocker(text:, cwd: nil)
+        # Note: This would need a Go implementation
+        raise NotImplementedError, 'add_blocker not yet implemented'
+      end
+
+      # Remove um blocker do STATE.md
+      #
+      # @param text [String] Texto do blocker
+      # @param cwd [String] Diretório de trabalho
+      def resolve_blocker(text:, cwd: nil)
+        # Note: This would need a Go implementation
+        raise NotImplementedError, 'resolve_blocker not yet implemented'
+      end
+    end
+
+    class HistoryError < StandardError; end
+  end
+end

data/lib/gsd/milestone.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # Milestone - Wrapper Ruby para operações de milestone via Go
+  module Milestone
+    class << self
+      # Completa um milestone
+      #
+      # @param version [String] Versão do milestone (ex: v1.0.0)
+      # @param name [String] Nome do milestone (opcional)
+      # @param archive_phases [Boolean] Arquivar phases do milestone
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def complete(version:, name: nil, archive_phases: false, cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'complete' => version }
+        args['name'] = name if name
+        args['archive-phases'] = 'true' if archive_phases
+        result = Go::Bridge.call('milestone', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise MilestoneError, result['error']
+        end
+      end
+
+      # Arquiva um milestone
+      #
+      # @param version [String] Versão do milestone
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def archive(version:, cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'archive' => version }
+        result = Go::Bridge.call('milestone', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise MilestoneError, result['error']
+        end
+      end
+
+      # Marca requirements como completos
+      #
+      # @param ids [Array<String>] IDs dos requirements
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def requirements_mark_complete(ids:, cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'requirements' => 'mark-complete', 'ids' => ids.join(',') }
+        result = Go::Bridge.call('milestone', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise MilestoneError, result['error']
+        end
+      end
+
+      # Helper: Verifica se milestone foi completado com sucesso
+      #
+      # @param result [Hash] Resultado da operação
+      # @return [Boolean] true se completado
+      def completed?(result)
+        result.is_a?(Hash) && result['success'] == true
+      end
+    end
+
+    class MilestoneError < StandardError; end
+  end
+end

data/lib/gsd/output.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Gsd
+  # Output formatting utilities
+  module Output
+    class << self
+      # JSON output
+      #
+      # @param data [Hash, Array] Data to output
+      # @param pretty [Boolean] Pretty print JSON
+      def json(data, pretty: true)
+        if pretty
+          puts JSON.pretty_generate(data)
+        else
+          puts JSON.generate(data)
+        end
+      end
+
+      # Raw key=value output
+      #
+      # @param data [Hash, Array, String] Data to output
+      def raw(data)
+        case data
+        when Hash
+          data.each { |k, v| puts "#{k}=#{v}" }
+        when Array
+          puts data.join("\n")
+        else
+          puts data
+        end
+      end
+
+      # Table output with borders
+      #
+      # @param headers [Array<String>] Column headers
+      # @param rows [Array<Array<String>>] Data rows
+      def table(headers, rows)
+        return if rows.empty?
+
+        # Calculate column widths
+        col_widths = headers.map(&:length)
+        rows.each do |row|
+          row.each_with_index do |cell, i|
+            col_widths[i] = [col_widths[i], cell.to_s.length].max
+          end
+        end
+
+        # Print header
+        puts headers.zip(col_widths).map { |h, w| h.ljust(w) }.join(' │ ')
+        puts '─' * (col_widths.sum + (headers.length - 1) * 3)
+
+        # Print rows
+        rows.each do |row|
+          puts row.zip(col_widths).map { |v, w| v.to_s.ljust(w) }.join(' │ ')
+        end
+      end
+
+      # Progress bar
+      #
+      # @param progress [Float] Progress value (0.0 to 1.0)
+      # @param width [Integer] Bar width in characters
+      def bar(progress, width: 40)
+        percentage = (progress * 100).round(1)
+        filled = (progress * width).round
+        empty = width - filled
+
+        bar = '█' * filled + '░' * empty
+        puts "[#{bar}] #{percentage}%"
+      end
+
+      # Formatted success message
+      #
+      # @param message [String] Success message
+      def success(message)
+        puts "✅ #{message}"
+      end
+
+      # Formatted warning message
+      #
+      # @param message [String] Warning message
+      def warning(message)
+        puts "⚠️  #{message}"
+      end
+
+      # Formatted error message
+      #
+      # @param message [String] Error message
+      def error(message)
+        puts "❌ #{message}"
+      end
+
+      # Formatted info message
+      #
+      # @param message [String] Info message
+      def info(message)
+        puts "ℹ️  #{message}"
+      end
+
+      # Formatted debug message (only if DEBUG env var is set)
+      #
+      # @param message [String] Debug message
+      def debug(message)
+        return unless ENV['GSD_DEBUG']
+        puts "🔍 [DEBUG] #{message}"
+      end
+
+      # Section header
+      #
+      # @param title [String] Section title
+      def section(title)
+        puts "\n#{'=' * 60}"
+        puts " #{title}"
+        puts "#{'=' * 60}\n"
+      end
+
+      # List with bullets
+      #
+      # @param items [Array<String>] List items
+      # @param bullet [String] Bullet character
+      def list(items, bullet: '•')
+        items.each { |item| puts "  #{bullet} #{item}" }
+      end
+
+      # Key-value pairs
+      #
+      # @param pairs [Hash] Key-value pairs
+      def kv(pairs)
+        max_key_length = pairs.keys.map(&:length).max
+        pairs.each do |key, value|
+          puts "#{key.to_s.ljust(max_key_length)}: #{value}"
+        end
+      end
+
+      # Divider line
+      #
+      # @param char [String] Divider character
+      # @param width [Integer] Line width
+      def divider(char: '─', width: 60)
+        puts char * width
+      end
+
+      # Status indicator
+      #
+      # @param status [Symbol] Status: :success, :warning, :error, :pending
+      # @param message [String] Status message
+      def status(status, message)
+        icon = case status
+               when :success then '✅'
+               when :warning then '⚠️'
+               when :error then '❌'
+               when :pending then '⏳'
+               else '•'
+               end
+        puts "#{icon} #{message}"
+      end
+
+      # Phase status display
+      #
+      # @param phase [String] Phase number
+      # @param name [String] Phase name
+      # @param status [Symbol] Phase status
+      def phase_status(phase, name, status)
+        icon = case status
+               when :complete then '✅'
+               when :in_progress then '🔄'
+               when :pending then '⏳'
+               else '•'
+               end
+        puts "#{icon} Phase #{phase}: #{name}"
+      end
+
+      # Plan progress display
+      #
+      # @param current [Integer] Current plan number
+      # @param total [Integer] Total plans
+      def plan_progress(current, total)
+        percentage = (current.to_f / total * 100).round
+        puts "📋 Plan #{current}/#{total} (#{percentage}%)"
+      end
+    end
+  end
+end

data/lib/gsd/phase.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # Phase - Wrapper Ruby para operações de phases via Go
+  class Phase
+    class << self
+      # Encontra uma phase pelo número ou nome
+      def find(phase_num, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.phase_find(phase_num, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise PhaseError, result['error']
+        end
+      end
+
+      # Lista todas as phases
+      def list(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.phase_list(cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise PhaseError, result['error']
+        end
+      end
+
+      # Calcula próxima phase decimal
+      def next_decimal(phase_num, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.phase_next_decimal(phase_num, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise PhaseError, result['error']
+        end
+      end
+
+      # Adiciona nova phase
+      def add(description, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.phase_add(description, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise PhaseError, result['error']
+        end
+      end
+
+      # Helper: verifica se phase existe
+      def exists?(phase_num, cwd: nil)
+        find(phase_num, cwd: cwd)
+        true
+      rescue PhaseError
+        false
+      end
+
+      # Helper: obtém path da phase
+      def path(phase_num, cwd: nil)
+        info = find(phase_num, cwd: cwd)
+        info['path']
+      end
+
+      # Helper: verifica se phase tem CONTEXT.md
+      def has_context?(phase_num, cwd: nil)
+        info = find(phase_num, cwd: cwd)
+        info['has_context']
+      end
+
+      # Helper: verifica se phase tem RESEARCH.md
+      def has_research?(phase_num, cwd: nil)
+        info = find(phase_num, cwd: cwd)
+        info['has_research']
+      end
+
+      # Helper: conta planos na phase
+      def plan_count(phase_num, cwd: nil)
+        info = find(phase_num, cwd: cwd)
+        info['plan_count']
+      end
+
+      # Helper: detecta próxima phase disponível
+      def detect_next(cwd: nil)
+        phases = list(cwd: cwd)
+        return nil if phases['phases'].empty?
+        
+        last_phase = phases['phases'].last
+        next_info = next_decimal(last_phase['number'], cwd: cwd)
+        next_info['next']
+      end
+    end
+
+    class PhaseError < StandardError; end
+  end
+end

data/lib/gsd/plugins/base.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Gsd
+  module Plugins
+    # Plugin Base Class - Classe base para todos os plugins
+    #
+    # Todos os plugins devem herdar desta classe
+    class Base
+      class << self
+        attr_accessor :name, :version, :description, :author
+
+        # Define o nome do plugin
+        def plugin_name(name)
+          @name = name
+        end
+
+        # Define a versão do plugin
+        def plugin_version(version)
+          @version = version
+        end
+
+        # Define a descrição do plugin
+        def plugin_description(desc)
+          @description = desc
+        end
+
+        # Define o autor do plugin
+        def plugin_author(author)
+          @author = author
+        end
+      end
+
+      # Inicializa o plugin
+      #
+      # @param config [Hash] Configuração do plugin
+      def initialize(config = {})
+        @config = config
+        @enabled = true
+      end
+
+      # Ativa o plugin
+      #
+      # @return [void]
+      def enable
+        @enabled = true
+        on_enable if respond_to?(:on_enable)
+      end
+
+      # Desativa o plugin
+      #
+      # @return [void]
+      def disable
+        @enabled = false
+        on_disable if respond_to?(:on_disable)
+      end
+
+      # Verifica se plugin está ativo
+      #
+      # @return [Boolean] true se ativo
+      def enabled?
+        @enabled
+      end
+
+      # Retorna informações do plugin
+      #
+      # @return [Hash] Informações
+      def info
+        {
+          name: self.class.name,
+          version: self.class.version,
+          description: self.class.description,
+          author: self.class.author,
+          enabled: @enabled
+        }
+      end
+
+      # Instala dependências do plugin
+      #
+      # @return [Boolean] true se sucesso
+      def install_dependencies
+        true
+      end
+
+      # Valida o plugin
+      #
+      # @return [Boolean] true se válido
+      def valid?
+        !self.class.name.nil? && !self.class.version.nil?
+      end
+    end
+  end
+end