fantasy-cli 1.2.6

data/lib/gsd/plugins/search.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Gsd
+  module Plugins
+    # Plugin Search - Busca avançada de plugins
+    #
+    # Responsável por:
+    # - Buscar plugins por nome, descrição, tags
+    # - Filtrar por categoria, versão, rating
+    # - Ordenar resultados
+    class Search
+      attr_reader :client
+
+      # Inicializa o Search
+      #
+      # @param client [MarketplaceClient] Cliente do marketplace
+      def initialize(client: nil)
+        @client = client || MarketplaceClient.new
+      end
+
+      # Busca plugins
+      #
+      # @param query [String] Query de busca
+      # @param options [Hash] Opções de busca
+      # @return [Array<Hash>] Resultados
+      def search(query, options = {})
+        filters = build_filters(options)
+        @client.search(query, filters)
+      end
+
+      # Busca por nome
+      #
+      # @param name [String] Nome ou parte do nome
+      # @return [Array<Hash>] Resultados
+      def by_name(name)
+        search(name, search_in: ['name'])
+      end
+
+      # Busca por descrição
+      #
+      # @param text [String] Texto da descrição
+      # @return [Array<Hash>] Resultados
+      def by_description(text)
+        search(text, search_in: ['description'])
+      end
+
+      # Busca por tags
+      #
+      # @param tags [Array<String>] Tags
+      # @return [Array<Hash>] Resultados
+      def by_tags(tags)
+        search('', tags: tags)
+      end
+
+      # Busca por autor
+      #
+      # @param author [String] Nome do autor
+      # @return [Array<Hash>] Resultados
+      def by_author(author)
+        search(author, author: author)
+      end
+
+      # Filtra por categoria
+      #
+      # @param category [String] Categoria
+      # @return [Array<Hash>] Resultados
+      def in_category(category)
+        @client.by_category(category)
+      end
+
+      # Plugins populares
+      #
+      # @param limit [Integer] Limite
+      # @return [Array<Hash>] Resultados
+      def popular(limit: 10)
+        @client.popular(limit: limit)
+      end
+
+      # Plugins recentes
+      #
+      # @param limit [Integer] Limite
+      # @return [Array<Hash>] Resultados
+      def recent(limit: 10)
+        @client.recent(limit: limit)
+      end
+
+      # Ordena resultados por rating
+      #
+      # @param results [Array<Hash>] Resultados
+      # @return [Array<Hash>] Resultados ordenados
+      def sort_by_rating(results)
+        results.sort_by { |r| -r['rating'].to_f }
+      end
+
+      # Ordena resultados por downloads
+      #
+      # @param results [Array<Hash>] Resultados
+      # @return [Array<Hash>] Resultados ordenados
+      def sort_by_downloads(results)
+        results.sort_by { |r| -r['downloads'].to_i }
+      end
+
+      # Ordena resultados por data
+      #
+      # @param results [Array<Hash>] Resultados
+      # @return [Array<Hash>] Resultados ordenados
+      def sort_by_date(results)
+        results.sort_by { |r| r['updated_at'] || r['created_at'] }.reverse
+      end
+
+      private
+
+      # Constrói filtros
+      #
+      # @param options [Hash] Opções
+      # @return [Hash] Filtros
+      def build_filters(options)
+        filters = {}
+
+        filters['search_in'] = options[:search_in].join(',') if options[:search_in]
+        filters['tags'] = options[:tags].join(',') if options[:tags]
+        filters['category'] = options[:category] if options[:category]
+        filters['min_rating'] = options[:min_rating] if options[:min_rating]
+        filters['min_downloads'] = options[:min_downloads] if options[:min_downloads]
+        filters['gsd_version'] = options[:gsd_version] if options[:gsd_version]
+
+        filters
+      end
+    end
+  end
+end

data/lib/gsd/plugins/validator.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Gsd
+  module Plugins
+    # Plugin Validator - Valida plugins
+    #
+    # Responsável por:
+    # - Validar estrutura do plugin
+    # - Validar metadata
+    # - Validar segurança
+    class Validator
+      # Erros de validação
+      attr_reader :errors
+
+      # Inicializa o Validator
+      def initialize
+        @errors = []
+      end
+
+      # Valida plugin
+      #
+      # @param path [String] Caminho do plugin
+      # @return [Boolean] true se válido
+      def validate(path)
+        @errors.clear
+
+        validate_structure(path)
+        validate_metadata(path)
+        validate_security(path)
+
+        @errors.empty?
+      end
+
+      # Valida e retorna erros
+      #
+      # @param path [String] Caminho do plugin
+      # @return [Array<String>] Lista de erros
+      def validate_with_errors(path)
+        validate(path)
+        @errors
+      end
+
+      private
+
+      # Valida estrutura de diretórios
+      #
+      # @param path [String] Caminho do plugin
+      # @return [void]
+      def validate_structure(path)
+        # Verifica se é diretório
+        unless File.directory?(path)
+          @errors << "Not a directory: #{path}"
+          return
+        end
+
+        # Verifica plugin.rb
+        unless File.exist?(File.join(path, 'plugin.rb'))
+          @errors << "Missing plugin.rb"
+        end
+
+        # Verifica plugin.json
+        unless File.exist?(File.join(path, 'plugin.json'))
+          @errors << "Missing plugin.json"
+        end
+      end
+
+      # Valida metadata
+      #
+      # @param path [String] Caminho do plugin
+      # @return [void]
+      def validate_metadata(path)
+        plugin_file = File.join(path, 'plugin.json')
+        return unless File.exist?(plugin_file)
+
+        begin
+          metadata = JSON.parse(File.read(plugin_file))
+
+          # Campos obrigatórios
+          %w[name version description].each do |field|
+            unless metadata[field]
+              @errors << "Missing required field: #{field}"
+            end
+          end
+
+          # Valida versão (semver)
+          if metadata['version'] && !valid_semver?(metadata['version'])
+            @errors << "Invalid version format: #{metadata['version']}"
+          end
+
+          # Valida nome
+          if metadata['name'] && !valid_name?(metadata['name'])
+            @errors << "Invalid plugin name: #{metadata['name']}"
+          end
+
+          # Valida gsd_version requirement
+          if metadata['gsd_version'] && !valid_version_requirement?(metadata['gsd_version'])
+            @errors << "Invalid gsd_version requirement: #{metadata['gsd_version']}"
+          end
+        rescue JSON::ParserError => e
+          @errors << "Invalid JSON in plugin.json: #{e.message}"
+        end
+      end
+
+      # Valida segurança
+      #
+      # @param path [String] Caminho do plugin
+      # @return [void]
+      def validate_security(path)
+        # Verifica arquivos suspeitos
+        suspicious_files = ['../../etc/passwd', '../..']
+
+        Dir.glob(File.join(path, '**', '*')).each do |file|
+          suspicious_files.each do |suspicious|
+            if file.include?(suspicious)
+              @errors << "Suspicious path detected: #{file}"
+            end
+          end
+        end
+
+        # Verifica se plugin.rb tenta acessar fora do diretório
+        plugin_rb = File.join(path, 'plugin.rb')
+        if File.exist?(plugin_rb)
+          content = File.read(plugin_rb)
+          if content.include?('`') || content.include?('system(')
+            @errors << "Plugin executes shell commands (potential security risk)"
+          end
+        end
+      end
+
+      # Valida versão semver
+      #
+      # @param version [String] Versão
+      # @return [Boolean] true se válido
+      def valid_semver?(version)
+        version.match?(/^\d+\.\d+\.\d+(-[a-zA-Z0-9]+)?$/)
+      end
+
+      # Valida nome do plugin
+      #
+      # @param name [String] Nome
+      # @return [Boolean] true se válido
+      def valid_name?(name)
+        name.match?(/^[a-z][a-z0-9-]*$/)
+      end
+
+      # Valida version requirement
+      #
+      # @param requirement [String] Requirement
+      # @return [Boolean] true se válido
+      def valid_version_requirement?(requirement)
+        requirement.match?(/^[>=<\s\d.]+$/)
+      end
+    end
+  end
+end

data/lib/gsd/plugins.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# GSD Plugins Module
+#
+# Sistema de plugins extensível para GSD Tools
+#
+# Uso:
+#   require 'gsd/plugins'
+#
+#   # Carregar manager
+#   manager = Gsd::Plugins::Manager.new
+#
+#   # Listar plugins
+#   plugins = manager.list
+#
+#   # Ativar plugin
+#   manager.enable('my-plugin')
+#
+#   # Marketplace
+#   marketplace = Gsd::Plugins::MarketplaceClient.new
+#   plugins = marketplace.search('github')
+#
+#   # Search
+#   search = Gsd::Plugins::Search.new
+#   results = search.by_name('git')
+#
+#   # Hooks
+#   hooks = Gsd::Plugins::Hooks.new
+#   hooks.register(:pre_command, 'my-plugin', ->(ctx) { puts "Before command" })
+#   hooks.run(:pre_command, { command: 'test' })
+
+module Gsd
+  module Plugins
+  end
+end
+
+# Load core plugin files
+require 'gsd/plugins/base'
+require 'gsd/plugins/manager'
+require 'gsd/plugins/loader'
+require 'gsd/plugins/installer'
+require 'gsd/plugins/validator'
+require 'gsd/plugins/sandbox'
+require 'gsd/plugins/marketplace'
+require 'gsd/plugins/search'
+require 'gsd/plugins/config'
+require 'gsd/plugins/hooks'
+require 'gsd/plugins/cli'

data/lib/gsd/profile.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # Profile - Wrapper Ruby para operações de profile via Go
+  module Profile
+    class << self
+      # Obtém um profile específico
+      #
+      # @param name [String] Nome do profile
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Profile data
+      def get(name, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('profile', { 'get' => name }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ProfileError, result['error']
+        end
+      end
+
+      # Define um profile
+      #
+      # @param name [String] Nome do profile
+      # @param model [String] Modelo do profile
+      # @param description [String] Descrição do profile
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def set(name, model, description: nil, cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'set' => name, 'model' => model }
+        args['description'] = description if description
+        result = Go::Bridge.call('profile', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ProfileError, result['error']
+        end
+      end
+
+      # Lista todos os profiles
+      #
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Lista de profiles
+      def list(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('profile', { 'list' => true }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ProfileError, result['error']
+        end
+      end
+
+      # Define o profile padrão
+      #
+      # @param name [String] Nome do profile
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def set_default(name, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('profile', { 'set-default' => name }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ProfileError, result['error']
+        end
+      end
+
+      # Obtém o profile para um agent type
+      #
+      # @param agent_type [String] Tipo do agent
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Profile data
+      def get_agent(agent_type, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('profile', { 'get-agent' => agent_type }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ProfileError, result['error']
+        end
+      end
+
+      # Define o profile para um agent type
+      #
+      # @param agent_type [String] Tipo do agent
+      # @param profile_name [String] Nome do profile
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def set_agent(agent_type, profile_name, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('profile', { 'set-agent' => [agent_type, profile_name].join(' ') }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ProfileError, result['error']
+        end
+      end
+
+      # Obtém a configuração do pipeline
+      #
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Pipeline config
+      def pipeline(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('profile', { 'pipeline' => true }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ProfileError, result['error']
+        end
+      end
+    end
+
+    class ProfileError < StandardError; end
+  end
+end

data/lib/gsd/research.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # Research - Wrapper Ruby para operações de research via Go
+  module Research
+    class << self
+      # Realiza uma pesquisa web usando Brave Search API
+      #
+      # @param query [String] Query de pesquisa
+      # @param limit [Integer] Número máximo de resultados
+      # @param freshness [String] Freshness filter (day, week, month)
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultados da pesquisa
+      def websearch(query, limit: 10, freshness: nil, cwd: nil)
+        cwd ||= Dir.pwd
+        args = { 'websearch' => query }
+        args['limit'] = limit.to_s if limit
+        args['freshness'] = freshness if freshness
+        result = Go::Bridge.call('research', args, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ResearchError, result['error']
+        end
+      end
+
+      # Inicia uma sessão de research para uma phase
+      #
+      # @param phase [String] Número da phase
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def start(phase, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('research', { 'start' => phase }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ResearchError, result['error']
+        end
+      end
+
+      # Completa uma sessão de research
+      #
+      # @param phase [String] Número da phase
+      # @param cwd [String] Diretório de trabalho
+      # @return [Hash] Resultado da operação
+      def complete(phase, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.call('research', { 'complete' => phase }, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise ResearchError, result['error']
+        end
+      end
+
+      # Helper: Verifica se a pesquisa retornou resultados
+      #
+      # @param result [Hash] Resultado da pesquisa
+      # @return [Boolean] true se há resultados
+      def has_results?(result)
+        result.is_a?(Hash) && result['success'] == true && 
+          result['data'] && result['data']['count'] && result['data']['count'] > 0
+      end
+
+      # Helper: Obtém os primeiros N resultados
+      #
+      # @param result [Hash] Resultado da pesquisa
+      # @param n [Integer] Número de resultados
+      # @return [Array] Primeiros N resultados
+      def top_results(result, n: 5)
+        return [] unless has_results?(result)
+        results = result['data']['results'] || []
+        results.first(n)
+      end
+    end
+
+    class ResearchError < StandardError; end
+  end
+end

data/lib/gsd/roadmap.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'go/bridge'
+
+module Gsd
+  # Roadmap - Wrapper Ruby para operações de ROADMAP.md via Go
+  class Roadmap
+    class << self
+      # Encontra uma phase no ROADMAP.md
+      def get_phase(phase_num, cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.roadmap_get_phase(phase_num, cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise RoadmapError, result['error']
+        end
+      end
+
+      # Analisa ROADMAP.md completo com status de disk
+      def analyze(cwd: nil)
+        cwd ||= Dir.pwd
+        result = Go::Bridge.roadmap_analyze(cwd: cwd)
+        
+        if result['success']
+          result['data']
+        else
+          raise RoadmapError, result['error']
+        end
+      end
+
+      # Helper: verifica se ROADMAP.md existe
+      def exists?(cwd: nil)
+        cwd ||= Dir.pwd
+        roadmap_path = File.join(cwd, '.planning', 'ROADMAP.md')
+        File.exist?(roadmap_path)
+      end
+
+      # Helper: obtém lista de fases do roadmap
+      def phases(cwd: nil)
+        analysis = analyze(cwd: cwd)
+        analysis['phases']
+      end
+
+      # Helper: conta total de fases
+      def phase_count(cwd: nil)
+        analysis = analyze(cwd: cwd)
+        analysis['total_phases']
+      end
+
+      # Helper: verifica se phase está no disk
+      def phase_on_disk?(phase_num, cwd: nil)
+        analysis = analyze(cwd: cwd)
+        phase_data = analysis['phases'].find { |p| p['number'] == phase_num }
+        phase_data && phase_data['on_disk']
+      end
+
+      # Helper: obtém milestone atual
+      def milestone(cwd: nil)
+        analysis = analyze(cwd: cwd)
+        analysis['milestone']
+      end
+
+      # Helper: obtém milestone branch
+      def milestone_branch(cwd: nil)
+        analysis = analyze(cwd: cwd)
+        analysis['milestone_branch']
+      end
+
+      # Helper: verifica se todas as phases estão no disk
+      def all_phases_on_disk?(cwd: nil)
+        phases = phases(cwd: cwd)
+        return false if phases.nil? || phases.empty?
+        
+        phases.all? { |p| p['on_disk'] }
+      end
+
+      # Helper: obtém phases sem diretório no disk
+      def missing_phase_dirs(cwd: nil)
+        phases = phases(cwd: cwd)
+        return [] if phases.nil?
+        
+        phases.select { |p| !p['on_disk'] }
+      end
+    end
+
+    class RoadmapError < StandardError; end
+  end
+end

data/lib/gsd/skills/bundled/commit.md

@@ -0,0 +1,58 @@
+---
+name: commit
+description: Create a commit with a well-formatted message
+aliases: [/git-commit]
+allowed_tools: [BashTool, FileReadTool]
+model: claude-sonnet-4-5-20250929
+---
+
+# Commit Skill
+
+When invoked, you will:
+1. Review all changed files
+2. Understand what was changed
+3. Write a clear commit message
+4. Create the commit
+5. Report the commit hash
+
+## User Request
+
+{{args}}
+
+## Commit Message Format
+
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+### Types
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation
+- `style`: Formatting
+- `refactor`: Code refactoring
+- `test`: Tests
+- `chore`: Maintenance
+
+### Example
+
+```
+feat(auth): add JWT token validation
+
+- Implement JWT token parsing
+- Add token expiration check
+- Update auth middleware
+
+Closes #123
+```
+
+## Instructions
+
+- Keep subject line under 50 characters
+- Wrap body at 72 characters
+- Explain WHAT and WHY, not HOW
+- Reference issues when applicable