fantasy-cli 1.2.14 → 1.3.0

data/lib/gsd/lsp/symbols.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+module Gsd
+  module LSP
+    # Symbols - Handles LSP document and workspace symbols
+    class Symbols
+      attr_reader :client, :cache, :cache_ttl
+
+      def initialize(client)
+        @client = client
+        @cache = {}
+        @cache_ttl = 30 # seconds
+        @mutex = Mutex.new
+      end
+
+      # Get document symbols
+      def document_symbols(uri)
+        return nil unless @client&.running?
+
+        cache_key = "doc:#{uri}"
+
+        # Check cache
+        cached = check_cache(cache_key)
+        return cached if cached
+
+        # Request from server
+        result = @client.document_symbol(uri)
+        return nil unless result
+
+        # Parse symbols
+        symbols = parse_symbols(result)
+
+        # Cache result
+        store_cache(cache_key, symbols)
+
+        symbols
+      end
+
+      # Get workspace symbols
+      def workspace_symbols(query = '')
+        return nil unless @client&.running?
+
+        cache_key = "ws:#{query}"
+
+        # Check cache
+        cached = check_cache(cache_key)
+        return cached if cached
+
+        # Request from server
+        result = @client.workspace_symbol(query)
+        return nil unless result
+
+        # Parse symbols
+        symbols = parse_symbols(result)
+
+        # Cache result
+        store_cache(cache_key, symbols)
+
+        symbols
+      end
+
+      # Get symbols at position
+      def symbol_at(symbols, line, character)
+        return nil unless symbols
+
+        symbols.find do |s|
+          range = s[:range]
+          next unless range
+
+          start_pos = range[:start]
+          end_pos = range[:end]
+
+          line >= start_pos[:line] && line <= end_pos[:line] &&
+            (line != start_pos[:line] || character >= start_pos[:character]) &&
+            (line != end_pos[:line] || character <= end_pos[:character])
+        end
+      end
+
+      # Filter symbols by name
+      def filter(symbols, pattern)
+        return symbols if pattern.empty?
+
+        regex = Regexp.new(pattern, Regexp::IGNORECASE)
+        symbols.select { |s| s[:name] =~ regex }
+      end
+
+      # Group symbols by kind
+      def group_by_kind(symbols)
+        symbols.group_by { |s| s[:kind] }
+      end
+
+      # Format symbol for display
+      def format_symbol(symbol, width: 50)
+        kind_icon = kind_to_icon(symbol[:kind])
+        name = symbol[:name]
+        detail = symbol[:detail]
+        line = symbol[:range]&.[]('start')&.[]('line') || symbol[:range]&.[](:start)&.[](:line)
+
+        text = "#{kind_icon} #{name}"
+        text += " (#{detail})" if detail && text.length + detail.length < width - 5
+        text += " L#{line + 1}" if line
+
+        text[0...width]
+      end
+
+      # Format symbol list for TUI
+      def format_list(symbols, selected_index: 0, width: 50, max_items: 15)
+        return [] if symbols.empty?
+
+        display_items = symbols.first(max_items)
+
+        display_items.map.with_index do |symbol, index|
+          prefix = index == selected_index ? '>' : ' '
+          formatted = format_symbol(symbol, width: width - 2)
+          "#{prefix} #{formatted}"
+        end
+      end
+
+      # Get breadcrumb path for symbol
+      def breadcrumb_path(symbols, line, character)
+        containing = symbols.select do |s|
+          range = s[:range]
+          next false unless range && s[:children]
+
+          start_pos = range[:start]
+          end_pos = range[:end]
+
+          line >= start_pos[:line] && line <= end_pos[:line] &&
+            (line != start_pos[:line] || character >= start_pos[:character]) &&
+            (line != end_pos[:line] || character <= end_pos[:character])
+        end
+
+        return [] if containing.empty?
+
+        # Find most specific container
+        innermost = containing.min_by do |s|
+          range = s[:range]
+          lines = range[:end][:line] - range[:start][:line]
+          chars = range[:end][:character] - range[:start][:character]
+          lines * 1000 + chars
+        end
+
+        path = [innermost]
+        path.concat(breadcrumb_path(innermost[:children] || [], line, character))
+        path
+      end
+
+      # Clear cache
+      def clear_cache
+        @mutex.synchronize do
+          @cache.clear
+        end
+      end
+
+      # Symbol outline (tree view)
+      def outline(symbols, indent: 0, max_depth: 5)
+        return [] if symbols.nil? || symbols.empty? || indent >= max_depth
+
+        lines = []
+
+        symbols.each do |symbol|
+          icon = kind_to_icon(symbol[:kind])
+          indent_str = '  ' * indent
+          name = symbol[:name]
+
+          lines << "#{indent_str}#{icon} #{name}"
+
+          # Add children
+          children = symbol[:children] || symbol['children']
+          if children && !children.empty?
+            lines.concat(outline(children, indent: indent + 1, max_depth: max_depth))
+          end
+        end
+
+        lines
+      end
+
+      private
+
+      def parse_symbols(result)
+        return [] unless result.is_a?(Array)
+
+        result.map { |s| normalize_symbol(s) }
+      end
+
+      def normalize_symbol(symbol)
+        {
+          name: symbol['name'] || symbol[:name],
+          kind: symbol['kind'] || symbol[:kind],
+          detail: symbol['detail'] || symbol[:detail],
+          range: symbol['location']&.[]('range') || symbol['range'] || symbol[:range],
+          uri: symbol['location']&.[]('uri') || symbol['uri'] || symbol[:uri],
+          children: parse_children(symbol['children'] || symbol[:children])
+        }
+      end
+
+      def parse_children(children)
+        return nil unless children.is_a?(Array)
+
+        children.map { |c| normalize_symbol(c) }
+      end
+
+      def check_cache(key)
+        @mutex.synchronize do
+          entry = @cache[key]
+          return nil unless entry
+
+          if Time.now - entry[:time] > @cache_ttl
+            @cache.delete(key)
+            nil
+          else
+            entry[:symbols]
+          end
+        end
+      end
+
+      def store_cache(key, symbols)
+        @mutex.synchronize do
+          @cache[key] = {
+            symbols: symbols,
+            time: Time.now
+          }
+
+          # Limit cache size
+          while @cache.size > 50
+            @cache.shift
+          end
+        end
+      end
+
+      def kind_to_icon(kind)
+        icons = {
+          1 => '📄',   # File
+          2 => '📦',   # Module
+          3 => '📦',   # Namespace
+          4 => '📦',   # Package
+          5 => 'ⓒ',   # Class
+          6 => 'ⓜ',   # Method
+          7 => 'ⓟ',   # Property
+          8 => 'ⓕ',   # Field
+          9 => 'ⓒ',   # Constructor
+          10 => 'ⓔ',  # Enum
+          11 => 'ⓘ',  # Interface
+          12 => 'ⓕ',  # Function
+          13 => 'ⓥ',  # Variable
+          14 => 'ⓒ',  # Constant
+          15 => '"',  # String
+          16 => '#',  # Number
+          17 => '✓',  # Boolean
+          18 => '[]', # Array
+          19 => '{}', # Object
+          20 => 'ⓚ',  # Key
+          21 => 'ⓘ',  # Null
+          22 => 'ⓔ',  # EnumMember
+          23 => '📄', # Struct
+          24 => '🔄', # Event
+          25 => 'ⓞ',  # Operator
+          26 => 'ⓣ'   # TypeParameter
+        }
+
+        icons[kind] || '❓'
+      end
+    end
+
+    # SymbolOutline - TUI panel for symbol outline
+    class SymbolOutline
+      attr_reader :visible, :width, :height, :symbols, :selected_index
+
+      def initialize(width: 40, height: 20)
+        @visible = false
+        @width = width
+        @height = height
+        @symbols = []
+        @selected_index = 0
+        @flattened = []
+      end
+
+      def show
+        @visible = true
+      end
+
+      def hide
+        @visible = false
+      end
+
+      def toggle
+        @visible = !@visible
+      end
+
+      def update(symbols)
+        @symbols = symbols || []
+        @selected_index = 0
+        flatten_symbols
+      end
+
+      def move_up
+        @selected_index = [@selected_index - 1, 0].max if @visible
+      end
+
+      def move_down
+        @selected_index = [@selected_index + 1, @flattened.length - 1].max if @visible
+      end
+
+      def current_symbol
+        @flattened[@selected_index]
+      end
+
+      def render
+        return [] unless @visible
+
+        lines = []
+        lines << '─' * @width
+        lines << ' Outline'.ljust(@width)
+        lines << '─' * @width
+
+        if @flattened.empty?
+          lines << ' No symbols'
+        else
+          display_items = @flattened.first(@height - 4)
+          display_items.each_with_index do |item, index|
+            prefix = (index + @selected_index.zero? ? '>' : ' ') rescue ' '
+            icon = kind_to_icon(item[:kind])
+            indent = '  ' * item[:depth]
+            name = item[:name][0...@width - indent.length - 5]
+            lines << "#{prefix} #{indent}#{icon} #{name}"
+          end
+        end
+
+        # Pad to height
+        while lines.length < @height
+          lines << ''
+        end
+
+        lines.first(@height)
+      end
+
+      private
+
+      def flatten_symbols
+        @flattened = []
+        flatten_recursive(@symbols, 0)
+      end
+
+      def flatten_recursive(symbols, depth)
+        return unless symbols
+
+        symbols.each do |s|
+          @flattened << s.merge(depth: depth)
+          children = s[:children] || s['children']
+          flatten_recursive(children, depth + 1) if children
+        end
+      end
+
+      def kind_to_icon(kind)
+        icons = {
+          1 => '📄', 2 => '📦', 3 => '📦', 4 => '📦',
+          5 => 'ⓒ', 6 => 'ⓜ', 7 => 'ⓟ', 8 => 'ⓕ',
+          9 => 'ⓒ', 10 => 'ⓔ', 11 => 'ⓘ', 12 => 'ⓕ',
+          13 => 'ⓥ', 14 => 'ⓒ', 15 => '"', 16 => '#',
+          17 => '✓', 18 => '[]', 19 => '{}', 20 => 'ⓚ',
+          21 => 'ⓘ', 22 => 'ⓔ', 23 => '📄', 24 => '🔄',
+          25 => 'ⓞ', 26 => 'ⓣ'
+        }
+        icons[kind] || '❓'
+      end
+    end
+  end
+end

data/lib/gsd/plugins/api.rb

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+module Gsd
+  module Plugins
+    # API - Interface pública para plugins
+    #
+    # Fornece métodos seguros para plugins interagirem com o sistema,
+    # sem expor detalhes internos perigosos.
+    class API
+      VERSION = '1.0.0'
+
+      def initialize(plugin_name)
+        @plugin_name = plugin_name
+        @registry = Registry.instance
+        @hooks = Hooks.instance
+      end
+
+      # === Informações do Sistema ===
+
+      # Versão da API
+      def api_version
+        VERSION
+      end
+
+      # Versão do Fantasy CLI
+      def cli_version
+        Gsd::VERSION
+      end
+
+      # Plataforma atual
+      def platform
+        RUBY_PLATFORM
+      end
+
+      # === Registro de Plugins ===
+
+      # Lista plugins instalados
+      def list_plugins
+        @registry.all.map(&:to_h)
+      end
+
+      # Verifica se plugin existe
+      def plugin_exists?(name)
+        @registry.exists?(name)
+      end
+
+      # Obtém informações de um plugin
+      def plugin_info(name)
+        plugin = @registry.get(name)
+        plugin&.to_h
+      end
+
+      # === Hooks e Eventos ===
+
+      # Registra handler para evento
+      def on(event, priority: 0, &block)
+        full_event = "#{@plugin_name}.#{event}"
+        @hooks.on(full_event, priority: priority, &block)
+      end
+
+      # Emite evento
+      def emit(event, *args)
+        full_event = "#{@plugin_name}.#{event}"
+        @hooks.trigger(full_event, *args)
+      end
+
+      # Escuta eventos de outros plugins
+      def listen_to(plugin, event, &block)
+        full_event = "#{plugin}.#{event}"
+        @hooks.on(full_event, &block)
+      end
+
+      # Escuta eventos globais
+      def listen_global(event, &block)
+        @hooks.on(event, &block)
+      end
+
+      # === Logging ===
+
+      # Log informativo
+      def log_info(message)
+        puts "[#{@plugin_name}] #{message}"
+      end
+
+      # Log de warning
+      def log_warn(message)
+        warn "[#{@plugin_name}] WARNING: #{message}"
+      end
+
+      # Log de erro
+      def log_error(message)
+        warn "[#{@plugin_name}] ERROR: #{message}"
+      end
+
+      # Log de debug (só em modo debug)
+      def log_debug(message)
+        return unless ENV['DEBUG']
+        puts "[#{@plugin_name}] DEBUG: #{message}"
+      end
+
+      # === Configuração ===
+
+      # Lê configuração do plugin
+      def get_config(key, default = nil)
+        path = config_path
+        return default unless File.exist?(path)
+
+        config = JSON.parse(File.read(path), symbolize_names: true)
+        config[key.to_sym] || default
+      rescue StandardError
+        default
+      end
+
+      # Salva configuração do plugin
+      def set_config(key, value)
+        path = config_path
+        config = {}
+
+        if File.exist?(path)
+          config = JSON.parse(File.read(path), symbolize_names: true)
+        end
+
+        config[key.to_sym] = value
+
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(config))
+      rescue StandardError => e
+        log_error("Failed to save config: #{e.message}")
+      end
+
+      # === Utilidades ===
+
+      # Lê arquivo (dentro de ~/.gsd apenas)
+      def read_file(path)
+        safe_path = File.expand_path(path, File.join(Dir.home, '.gsd'))
+        return nil unless File.exist?(safe_path)
+        return nil unless safe_path.start_with?(File.join(Dir.home, '.gsd'))
+
+        File.read(safe_path)
+      rescue StandardError
+        nil
+      end
+
+      # Escreve arquivo (dentro de ~/.gsd apenas)
+      def write_file(path, content)
+        safe_path = File.expand_path(path, File.join(Dir.home, '.gsd'))
+        return false unless safe_path.start_with?(File.join(Dir.home, '.gsd'))
+
+        FileUtils.mkdir_p(File.dirname(safe_path))
+        File.write(safe_path, content)
+        true
+      rescue StandardError
+        false
+      end
+
+      # HTTP GET (com timeout)
+      def http_get(url, timeout: 10)
+        require 'net/http'
+        require 'uri'
+
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+
+        response = http.get(uri.request_uri)
+        response.body
+      rescue StandardError => e
+        log_error("HTTP GET failed: #{e.message}")
+        nil
+      end
+
+      # === UI (para plugins TUI) ===
+
+      # Adiciona mensagem ao output (se TUI estiver ativo)
+      def ui_message(text, type: :system)
+        return unless defined?(Gsd::TUI::App)
+
+        # Envia via hook para ser capturado pelo App
+        @hooks.trigger('tui.message', { text: text, type: type, plugin: @plugin_name })
+      end
+
+      # Adiciona comando à palette (se TUI estiver ativo)
+      def ui_command(name, description, &block)
+        @hooks.trigger('tui.register_command', {
+          name: name,
+          description: description,
+          plugin: @plugin_name,
+          callback: block
+        })
+      end
+
+      # === Timers ===
+
+      # Executa código após delay
+      def set_timeout(seconds, &block)
+        Thread.new do
+          sleep(seconds)
+          block.call
+        end
+      end
+
+      # Executa código periodicamente
+      def set_interval(seconds, &block)
+        Thread.new do
+          loop do
+            sleep(seconds)
+            block.call
+          end
+        end
+      end
+
+      # === Storage ===
+
+      # Salva dados (key-value store)
+      def storage_set(key, value)
+        storage_path = File.join(Dir.home, '.gsd', 'storage', "#{@plugin_name}.json")
+        data = {}
+
+        if File.exist?(storage_path)
+          data = JSON.parse(File.read(storage_path), symbolize_names: true)
+        end
+
+        data[key.to_sym] = value
+        FileUtils.mkdir_p(File.dirname(storage_path))
+        File.write(storage_path, JSON.pretty_generate(data))
+      end
+
+      # Lê dados
+      def storage_get(key, default = nil)
+        storage_path = File.join(Dir.home, '.gsd', 'storage', "#{@plugin_name}.json")
+        return default unless File.exist?(storage_path)
+
+        data = JSON.parse(File.read(storage_path), symbolize_names: true)
+        data.fetch(key.to_sym, default)
+      rescue StandardError
+        default
+      end
+
+      # Limpa storage
+      def storage_clear
+        storage_path = File.join(Dir.home, '.gsd', 'storage', "#{@plugin_name}.json")
+        File.delete(storage_path) if File.exist?(storage_path)
+      end
+
+      private
+
+      def config_path
+        File.join(Dir.home, '.gsd', 'plugins', @plugin_name, 'config.json')
+      end
+    end
+
+    # PluginContext - Contexto para execução de plugins
+    # Fornece um ambiente isolado onde o plugin roda
+    class PluginContext
+      SAFE_METHODS = %i[
+        puts print p puts print
+        map select reject each each_with_index
+        chomp split gsub sub strip
+        length size empty? nil?
+        to_s to_i to_f to_a to_h to_sym
+        freeze dup clone
+        upcase downcase capitalize
+        include? start_with? end_with?
+        + - * / % ** << >>
+        == != < > <= >= <=>
+        [] []= fetch dig
+        keys values has_key?
+        new create
+        sleep rand srand
+        time Time.now
+      ].freeze
+
+      def initialize(api)
+        @api = api
+        @exports = {}
+      end
+
+      # Executa plugin em contexto seguro
+      def run(code)
+        create_binding.instance_eval(code)
+      rescue StandardError => e
+        @api.log_error("Execution error: #{e.message}")
+        nil
+      end
+
+      # Exporta função para outros plugins
+      def export(name, &block)
+        @exports[name] = block
+      end
+
+      # Chama função exportada de outro plugin
+      def import(plugin_name, function_name, *args)
+        # Implementação via registry
+        plugin = Registry.instance.get(plugin_name)
+        return nil unless plugin
+
+        context = plugin.instance_variable_get(:@context)
+        return nil unless context
+
+        handler = context.instance_variable_get(:@exports)[function_name]
+        return nil unless handler
+
+        handler.call(*args)
+      end
+
+      private
+
+      def create_binding
+        binding_context = Object.new
+
+        # Define métodos seguros
+        SAFE_METHODS.each do |method|
+          define_safe_method(binding_context, method)
+        end
+
+        # Expõe API
+        binding_context.define_singleton_method(:api) { @api }
+        binding_context.define_singleton_method(:export) { |n, &b| export(n, &b) }
+        binding_context.define_singleton_method(:import) { |p, f, *a| import(p, f, *a) }
+
+        binding_context.instance_variable_set(:@api, @api)
+        binding_context.instance_variable_set(:@context, self)
+
+        binding_context
+      end
+
+      def define_safe_method(obj, method_name)
+        obj.define_singleton_method(method_name) do |*args, &block|
+          if args.first.respond_to?(method_name)
+            args.first.send(method_name, *args[1..-1], &block)
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end