fantasy-cli 1.2.6

data/lib/gsd/validator.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+
+module Gsd
+  # Input validation utilities
+  class Validator
+    class << self
+      # Phase number validation
+      #
+      # @param phase [String] Phase number to validate
+      # @return [String] Validated phase number
+      # @raise [ValidationError] If phase format is invalid
+      def phase_number(phase)
+        return phase if phase =~ /^\d+(\.\d+)?$/
+
+        raise ValidationError.new(
+          'phase',
+          phase,
+          'Invalid phase number format. Use: 1, 1.1, 2.3, etc.'
+        )
+      end
+
+      # Field name validation for state
+      #
+      # @param field [String] Field name to validate
+      # @return [String] Validated field name
+      # @raise [ValidationError] If field is invalid
+      def state_field(field)
+        valid_fields = %w[
+          model_profile current_phase plans_of plans_total
+          progress milestone milestone_branch active_workspace
+        ]
+
+        return field if valid_fields.include?(field)
+
+        raise ValidationError.new(
+          'field',
+          field,
+          "Invalid field. Must be one of: #{valid_fields.join(', ')}"
+        )
+      end
+
+      # Path exists validation
+      #
+      # @param path [String] Path to validate
+      # @param name [String] Name for error message
+      # @return [String] Validated path
+      # @raise [NotFoundError] If path doesn't exist
+      def path_exists(path, name = 'Path')
+        return path if File.exist?(path)
+
+        raise NotFoundError.new(name, path)
+      end
+
+      # Planning directory validation
+      #
+      # @param cwd [String] Working directory
+      # @return [String] Planning directory path
+      # @raise [NotFoundError] If planning directory doesn't exist
+      def planning_dir_exists(cwd)
+        planning_path = File.join(cwd, '.planning')
+        return planning_path if File.directory?(planning_path)
+
+        raise NotFoundError.new('planning directory', planning_path)
+      end
+
+      # Phase directory validation
+      #
+      # @param phase_num [String] Phase number
+      # @param cwd [String] Working directory
+      # @return [String] Phase directory path
+      # @raise [NotFoundError] If phase directory doesn't exist
+      def phase_dir_exists(phase_num, cwd)
+        phases_dir = File.join(cwd, '.planning', 'phases')
+
+        unless File.directory?(phases_dir)
+          raise NotFoundError.new('phases directory', phases_dir)
+        end
+
+        # Find phase directory
+        entries = Dir.entries(phases_dir).select { |e| File.directory?(File.join(phases_dir, e)) }
+        phase_entry = entries.find { |e| e.start_with?(phase_num) || e.include?("-#{phase_num}-") }
+
+        return File.join(phases_dir, phase_entry) if phase_entry
+
+        raise NotFoundError.new('phase', phase_num)
+      end
+
+      # File extension validation
+      #
+      # @param path [String] File path
+      # @param expected_ext [String] Expected extension (without dot)
+      # @return [String] Validated path
+      # @raise [ValidationError] If extension doesn't match
+      def file_extension(path, expected_ext)
+        ext = File.extname(path)
+        return path if ext == ".#{expected_ext}"
+
+        raise ValidationError.new(
+          'file extension',
+          ext,
+          "Expected .#{expected_ext}, got #{ext}"
+        )
+      end
+
+      # Non-empty string validation
+      #
+      # @param value [String] Value to validate
+      # @param name [String] Field name for error message
+      # @return [String] Validated string
+      # @raise [ValidationError] If value is empty
+      def non_empty_string(value, name)
+        return value if value.is_a?(String) && !value.strip.empty?
+
+        raise ValidationError.new(
+          name,
+          value.inspect,
+          "#{name} must be a non-empty string"
+        )
+      end
+
+      # Positive integer validation
+      #
+      # @param value [Integer] Value to validate
+      # @param name [String] Field name for error message
+      # @return [Integer] Validated integer
+      # @raise [ValidationError] If value is not positive
+      def positive_integer(value, name)
+        return value if value.is_a?(Integer) && value > 0
+
+        raise ValidationError.new(
+          name,
+          value.inspect,
+          "#{name} must be a positive integer"
+        )
+      end
+
+      # Percentage validation (0-100)
+      #
+      # @param value [Numeric] Value to validate
+      # @return [Numeric] Validated percentage
+      # @raise [ValidationError] If value is out of range
+      def percentage(value)
+        num = value.to_f
+        return num if num >= 0 && num <= 100
+
+        raise ValidationError.new(
+          'percentage',
+          value,
+          'Percentage must be between 0 and 100'
+        )
+      end
+
+      # Model profile validation
+      #
+      # @param profile [String] Model profile name
+      # @return [String] Validated profile
+      # @raise [ValidationError] If profile is invalid
+      def model_profile(profile)
+        return profile if profile =~ /^[a-z0-9_-]+$/
+
+        raise ValidationError.new(
+          'model_profile',
+          profile,
+          'Model profile must contain only lowercase letters, numbers, hyphens, and underscores'
+        )
+      end
+
+      # Git commit message validation
+      #
+      # @param message [String] Commit message
+      # @return [String] Validated message
+      # @raise [ValidationError] If message is invalid
+      def commit_message(message)
+        return message if message.is_a?(String) && message.length >= 5
+
+        raise ValidationError.new(
+          'message',
+          message.inspect,
+          'Commit message must be at least 5 characters'
+        )
+      end
+
+      # Slug validation
+      #
+      # @param slug [String] Slug to validate
+      # @return [String] Validated slug
+      # @raise [ValidationError] If slug is invalid
+      def slug(slug)
+        return slug if slug =~ /^[a-z0-9]+(-[a-z0-9]+)*$/
+
+        raise ValidationError.new(
+          'slug',
+          slug,
+          'Slug must be lowercase alphanumeric with hyphens'
+        )
+      end
+
+      # Workspace name validation
+      #
+      # @param name [String] Workspace name
+      # @return [String] Validated name
+      # @raise [ValidationError] If name is invalid
+      def workspace_name(name)
+        return name if name =~ /^[a-zA-Z0-9_-]+$/
+
+        raise ValidationError.new(
+          'workspace',
+          name,
+          'Workspace name must be alphanumeric, hyphens, and underscores only'
+        )
+      end
+    end
+  end
+end

data/lib/gsd/verify.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # Verify - Wrapper Ruby para operações de verificação via Go
+  module Verify
+    class << self
+      # Verifica estrutura de um PLAN.md
+      #
+      # @param file [String] Caminho para o arquivo PLAN.md
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da verificação
+      def plan_structure(file:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('verify', { 'plan-structure' => file }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise VerifyError, result['error']
+        end
+      end
+
+      # Verifica se todos os plans têm summaries correspondentes
+      #
+      # @param phase [String] Número da phase
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da verificação
+      def phase_completeness(phase:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('verify', { 'phase-completeness' => phase }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise VerifyError, result['error']
+        end
+      end
+
+      # Verifica referências (@-refs e paths)
+      #
+      # @param file [String] Caminho para o arquivo
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da verificação
+      def references(file:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('verify', { 'references' => file }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise VerifyError, result['error']
+        end
+      end
+
+      # Verifica commits hashes
+      #
+      # @param hashes [Array<String>] Lista de commit hashes
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da verificação
+      def commits(hashes:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('verify', { 'commits' => hashes.join(' ') }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise VerifyError, result['error']
+        end
+      end
+
+      # Verifica artefatos obrigatórios
+      #
+      # @param file [String] Caminho para o arquivo PLAN.md
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da verificação
+      def artifacts(file:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('verify', { 'artifacts' => file }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise VerifyError, result['error']
+        end
+      end
+
+      # Verifica links obrigatórios
+      #
+      # @param file [String] Caminho para o arquivo PLAN.md
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da verificação
+      def key_links(file:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('verify', { 'key-links' => file }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise VerifyError, result['error']
+        end
+      end
+
+      # Verifica formatação de tasks
+      #
+      # @param file [String] Caminho para o arquivo
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da verificação
+      def tasks(file:, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('verify', { 'tasks' => file }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise VerifyError, result['error']
+        end
+      end
+
+      # Verifica estrutura de SUMMARY.md
+      #
+      # @param file [String] Caminho para o arquivo SUMMARY.md
+      # @param check_count [Integer] Número mínimo de tasks completas esperadas
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da verificação
+      def summary(file:, check_count: 2, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('verify', { 'summary' => file, 'check-count' => check_count.to_s }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise VerifyError, result['error']
+        end
+      end
+
+      # Helper: Verifica se uma verificação passou
+      #
+      # @param result [Hash] Resultado da verificação
+      # @return [Boolean] true se passou
+      def passed?(result)
+        result.is_a?(Hash) && result['success'] == true
+      end
+
+      # Helper: Verifica se uma verificação falhou
+      #
+      # @param result [Hash] Resultado da verificação
+      # @return [Boolean] true se falhou
+      def failed?(result)
+        result.is_a?(Hash) && result['success'] != true
+      end
+
+      # Helper: Obtém erros de uma verificação
+      #
+      # @param result [Hash] Resultado da verificação
+      # @return [Array<String>] Lista de erros
+      def errors(result)
+        return [] unless result.is_a?(Hash)
+        result['errors'] || result['data']&.dig('errors') || []
+      end
+
+      # Helper: Obtém warnings de uma verificação
+      #
+      # @param result [Hash] Resultado da verificação
+      # @return [Array<String>] Lista de warnings
+      def warnings(result)
+        return [] unless result.is_a?(Hash)
+        result['warnings'] || result['data']&.dig('warnings') || []
+      end
+    end
+
+    class VerifyError < StandardError; end
+  end
+end

data/lib/gsd/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gsd
+  VERSION = '1.2.6'
+end

data/lib/gsd/workstream.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # Workstream - Wrapper Ruby para operações de workstream via Go
+  module Workstream
+    class << self
+      # Obtém o workstream atual
+      #
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Workstream info
+      def get(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('workstream', { 'get' => true }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise WorkstreamError, result['error']
+        end
+      end
+
+      # Define o workstream ativo
+      #
+      # @param name [String] Nome do workstream
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def set(name, cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'set' => name }
+        result = Go::Bridge.call('workstream', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise WorkstreamError, result['error']
+        end
+      end
+
+      # Lista todos os workstreams
+      #
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Lista de workstreams
+      def list(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('workstream', { 'list' => true }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise WorkstreamError, result['error']
+        end
+      end
+
+      # Limpa o workstream ativo
+      #
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def clear(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('workstream', { 'clear' => true }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise WorkstreamError, result['error']
+        end
+      end
+
+      # Helper: Verifica se há um workstream ativo
+      #
+      # @param result [Hash] Resultado do get
+      # @return [Boolean] true se ativo
+      def active?(result)
+        result.is_a?(Hash) && result['active'] == true
+      end
+
+      # Helper: Obtém nome do workstream ativo
+      #
+      # @param result [Hash] Resultado do get
+      # @return [String, nil] Nome do workstream ou nil
+      def name(result)
+        return nil unless result.is_a?(Hash)
+        result['workstream']
+      end
+    end
+
+    class WorkstreamError < StandardError; end
+  end
+end