fantasy-cli 1.2.14 → 1.3.0

data/lib/gsd/lsp/diagnostics.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module Gsd
+  module LSP
+    # Diagnostics - Manages LSP diagnostics display
+    class Diagnostics
+      attr_reader :by_file, :max_diagnostics
+
+      def initialize(max: 100)
+        @by_file = {}
+        @max_diagnostics = max
+        @mutex = Mutex.new
+      end
+
+      # Add/update diagnostics for a file
+      def update(uri, diagnostics)
+        @mutex.synchronize do
+          file_path = uri_to_path(uri)
+          @by_file[file_path] = diagnostics.first(@max_diagnostics)
+        end
+      end
+
+      # Get diagnostics for a file
+      def for_file(file_path)
+        @mutex.synchronize do
+          @by_file[file_path] || []
+        end
+      end
+
+      # Get diagnostics for a specific line
+      def at_line(file_path, line)
+        diagnostics = for_file(file_path)
+        diagnostics.select { |d| d.range.start.line == line }
+      end
+
+      # Get diagnostics at position
+      def at_position(file_path, line, character)
+        diagnostics = for_file(file_path)
+        diagnostics.select do |d|
+          range = d.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
+
+      # Count total diagnostics
+      def count
+        @mutex.synchronize do
+          @by_file.values.sum(&:length)
+        end
+      end
+
+      # Count by severity
+      def count_by_severity
+        @mutex.synchronize do
+          counts = { error: 0, warning: 0, information: 0, hint: 0 }
+
+          @by_file.each_value do |diagnostics|
+            diagnostics.each do |d|
+              case d.severity
+              when 1 then counts[:error] += 1
+              when 2 then counts[:warning] += 1
+              when 3 then counts[:information] += 1
+              when 4 then counts[:hint] += 1
+              end
+            end
+          end
+
+          counts
+        end
+      end
+
+      # Clear diagnostics for a file
+      def clear_file(file_path)
+        @mutex.synchronize do
+          @by_file.delete(file_path)
+        end
+      end
+
+      # Clear all diagnostics
+      def clear_all
+        @mutex.synchronize do
+          @by_file.clear
+        end
+      end
+
+      # List files with diagnostics
+      def files
+        @mutex.synchronize do
+          @by_file.keys.dup
+        end
+      end
+
+      # Get all diagnostics as flat list
+      def all
+        @mutex.synchronize do
+          @by_file.flat_map do |file, diagnostics|
+            diagnostics.map { |d| { file: file, diagnostic: d } }
+          end
+        end
+      end
+
+      # Render diagnostics for display
+      def render_for_file(file_path, width: 80)
+        diagnostics = for_file(file_path)
+        return [] if diagnostics.empty?
+
+        diagnostics.map do |d|
+          severity_char = severity_to_char(d.severity)
+          location = "#{d.range.start.line + 1}:#{d.range.start.character + 1}"
+          message = d.message.lines.first.chomp
+
+          "#{severity_char} [#{location}] #{message[0...width - 10]}"
+        end
+      end
+
+      # Format diagnostic for TUI
+      def format_for_tui(file_path, width: 80)
+        lines = []
+        diagnostics = for_file(file_path)
+
+        return lines if diagnostics.empty?
+
+        lines << "📋 Diagnostics (#{diagnostics.length}):"
+
+        diagnostics.first(10).each do |d|
+          icon = severity_to_icon(d.severity)
+          line = d.range.start.line + 1
+          message = d.message.lines.first.chomp[0...width - 15]
+          lines << "  #{icon} L#{line}: #{message}"
+        end
+
+        if diagnostics.length > 10
+          lines << "  ... and #{diagnostics.length - 10} more"
+        end
+
+        lines
+      end
+
+      # Check if file has errors
+      def has_errors?(file_path)
+        diagnostics = for_file(file_path)
+        diagnostics.any? { |d| d.severity == 1 }
+      end
+
+      # Check if file has warnings
+      def has_warnings?(file_path)
+        diagnostics = for_file(file_path)
+        diagnostics.any? { |d| d.severity == 2 }
+      end
+
+      # Get error count for file
+      def error_count(file_path)
+        for_file(file_path).count { |d| d.severity == 1 }
+      end
+
+      # Get warning count for file
+      def warning_count(file_path)
+        for_file(file_path).count { |d| d.severity == 2 }
+      end
+
+      # Summary for status bar
+      def status_summary
+        counts = count_by_severity
+        parts = []
+        parts << "E:#{counts[:error]}" if counts[:error] > 0
+        parts << "W:#{counts[:warning]}" if counts[:warning] > 0
+        parts.join(' ') unless parts.empty?
+      end
+
+      private
+
+      def uri_to_path(uri)
+        return uri unless uri.start_with?('file://')
+
+        uri[7..-1]
+      end
+
+      def severity_to_char(severity)
+        case severity
+        when 1 then 'E'
+        when 2 then 'W'
+        when 3 then 'I'
+        when 4 then 'H'
+        else '?'
+        end
+      end
+
+      def severity_to_icon(severity)
+        case severity
+        when 1 then '🔴'
+        when 2 then '🟡'
+        when 3 then '🔵'
+        when 4 then '💡'
+        else '❓'
+        end
+      end
+    end
+
+    # DiagnosticsPanel - TUI panel for diagnostics
+    class DiagnosticsPanel
+      attr_reader :visible, :width, :height
+
+      def initialize(width: 60, height: 15)
+        @visible = false
+        @width = width
+        @height = height
+        @diagnostics = Diagnostics.new
+        @current_file = nil
+      end
+
+      def show
+        @visible = true
+      end
+
+      def hide
+        @visible = false
+      end
+
+      def toggle
+        @visible = !@visible
+      end
+
+      def update(uri, diagnostics)
+        @diagnostics.update(uri, diagnostics)
+      end
+
+      def set_current_file(file_path)
+        @current_file = file_path
+      end
+
+      def render
+        return [] unless @visible
+
+        lines = []
+        lines << '─' * @width
+        lines << ' Diagnostics'.ljust(@width)
+        lines << '─' * @width
+
+        if @current_file
+          lines.concat(@diagnostics.format_for_tui(@current_file, width: @width))
+        else
+          lines << ' No file selected'
+        end
+
+        # Pad to height
+        while lines.length < @height
+          lines << ''
+        end
+
+        lines.first(@height)
+      end
+    end
+  end
+end

data/lib/gsd/lsp/hover.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Gsd
+  module LSP
+    # Hover - Handles LSP hover information
+    class Hover
+      attr_reader :client, :cache, :cache_ttl
+
+      def initialize(client)
+        @client = client
+        @cache = {}
+        @cache_ttl = 10 # seconds
+        @mutex = Mutex.new
+      end
+
+      # Get hover info at position
+      def get(uri, line, character)
+        return nil unless @client&.running?
+
+        cache_key = "#{uri}:#{line}:#{character}"
+
+        # Check cache
+        cached = check_cache(cache_key)
+        return cached if cached
+
+        # Request from server
+        result = @client.hover(uri, line, character)
+        return nil unless result
+
+        # Parse hover
+        info = parse_hover_result(result)
+
+        # Cache result
+        store_cache(cache_key, info)
+
+        info
+      end
+
+      # Get hover at cursor from text
+      def get_at_cursor(file_path, text, cursor_pos)
+        line, character = position_from_offset(text, cursor_pos)
+        uri = path_to_uri(file_path)
+
+        get(uri, line, character)
+      end
+
+      # Format hover for display
+      def format(info, width: 60, max_height: 10)
+        return nil unless info
+
+        contents = info[:contents]
+        return nil if contents.nil? || contents.empty?
+
+        lines = extract_lines(contents)
+        return nil if lines.empty?
+
+        # Format and truncate
+        formatted = lines.map { |line| line[0...width] }
+        formatted.first(max_height)
+      end
+
+      # Format hover for TUI panel
+      def format_for_tui(info, width: 60, max_height: 10)
+        return [] unless info
+
+        lines = format(info, width: width - 2, max_height: max_height - 2)
+        return [] unless lines
+
+        result = []
+        result << '─' * width
+        result << ' Hover'.ljust(width)
+        result << '─' * width
+
+        lines.each { |line| result << " #{line}" }
+
+        # Pad to max_height
+        while result.length < max_height
+          result << ''
+        end
+
+        result.first(max_height)
+      end
+
+      # Get type information
+      def type_info(info)
+        return nil unless info
+
+        contents = info[:contents]
+        return nil if contents.nil?
+
+        # Extract type from hover info
+        if contents.is_a?(String)
+          extract_type_from_string(contents)
+        elsif contents.is_a?(Hash)
+          contents['value'] || contents[:value]
+        elsif contents.is_a?(Array)
+          contents.first&.[]('value') || contents.first&.[](:value)
+        end
+      end
+
+      # Clear cache
+      def clear_cache
+        @mutex.synchronize do
+          @cache.clear
+        end
+      end
+
+      private
+
+      def parse_hover_result(result)
+        contents = result['contents'] || result[:contents]
+
+        {
+          contents: contents,
+          range: result['range'] || result[:range]
+        }
+      end
+
+      def extract_lines(contents)
+        return [] unless contents
+
+        if contents.is_a?(String)
+          contents.lines
+        elsif contents.is_a?(Hash)
+          value = contents['value'] || contents[:value]
+          value ? value.lines : []
+        elsif contents.is_a?(Array)
+          contents.flat_map do |item|
+            if item.is_a?(String)
+              item.lines
+            elsif item.is_a?(Hash)
+              value = item['value'] || item[:value]
+              value ? value.lines : []
+            else
+              []
+            end
+          end
+        else
+          []
+        end
+      end
+
+      def extract_type_from_string(str)
+        # Try to extract type from common patterns
+        # Ruby: "[Float] method description"
+        # TypeScript: "(parameter) x: string"
+        # Python: "function foo -> int"
+
+        if str =~ /^\[([^\]]+)\]/
+          return $1
+        elsif str =~ /:\s*(\S+)\s*$/
+          return $1
+        elsif str =~ /->\s*(\S+)/
+          return $1
+        end
+
+        nil
+      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[:info]
+          end
+        end
+      end
+
+      def store_cache(key, info)
+        @mutex.synchronize do
+          @cache[key] = {
+            info: info,
+            time: Time.now
+          }
+
+          # Limit cache size
+          while @cache.size > 100
+            @cache.shift
+          end
+        end
+      end
+
+      def position_from_offset(text, offset)
+        line = 0
+        character = 0
+
+        text[0...offset].each_char do |char|
+          if char == "\n"
+            line += 1
+            character = 0
+          else
+            character += 1
+          end
+        end
+
+        [line, character]
+      end
+
+      def path_to_uri(path)
+        absolute = File.expand_path(path)
+        "file://#{absolute}"
+      end
+    end
+
+    # HoverPanel - TUI panel for hover info
+    class HoverPanel
+      attr_reader :visible, :width, :height, :current_info
+
+      def initialize(width: 60, height: 12)
+        @visible = false
+        @width = width
+        @height = height
+        @current_info = nil
+      end
+
+      def show
+        @visible = true
+      end
+
+      def hide
+        @visible = false
+      end
+
+      def toggle
+        @visible = !@visible
+      end
+
+      def update(info)
+        @current_info = info
+      end
+
+      def render
+        return [] unless @visible
+
+        Hover.new(nil).format_for_tui(@current_info, width: @width, max_height: @height)
+      end
+    end
+  end
+end