konpeito 0.1.0

data/lib/konpeito/lsp/server.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative "transport"
+require_relative "document_manager"
+
+module Konpeito
+  module LSP
+    # Main LSP server that handles client requests
+    class Server
+      attr_reader :transport, :document_manager
+
+      def initialize(input: $stdin, output: $stdout)
+        @transport = Transport.new(input: input, output: output)
+        @document_manager = DocumentManager.new(@transport)
+        @running = false
+        @initialized = false
+      end
+
+      # Start the LSP server main loop
+      def start
+        @running = true
+        while @running
+          request = @transport.read
+          break unless request
+
+          response = handle_request(request)
+          @transport.write(response) if response
+        end
+      end
+
+      # Stop the server
+      def stop
+        @running = false
+      end
+
+      # Handle a single request (exposed for testing)
+      # @param request [Hash] The LSP request
+      # @return [Hash, nil] The response or nil for notifications
+      def handle_request(request)
+        method = request[:method]
+        id = request[:id]
+        params = request[:params] || {}
+
+        result = case method
+        when "initialize"
+          handle_initialize(params)
+        when "initialized"
+          # Notification, no response needed
+          nil
+        when "shutdown"
+          handle_shutdown
+        when "exit"
+          @running = false
+          nil
+        when "textDocument/didOpen"
+          handle_did_open(params)
+        when "textDocument/didChange"
+          handle_did_change(params)
+        when "textDocument/didClose"
+          handle_did_close(params)
+        when "textDocument/hover"
+          handle_hover(params)
+        when "textDocument/completion"
+          handle_completion(params)
+        when "textDocument/definition"
+          handle_definition(params)
+        when "textDocument/references"
+          handle_references(params)
+        when "textDocument/rename"
+          handle_rename(params)
+        when "textDocument/prepareRename"
+          handle_prepare_rename(params)
+        else
+          # Unknown method
+          if id
+            { error: { code: -32601, message: "Method not found: #{method}" } }
+          end
+        end
+
+        # Build response for requests (not notifications)
+        if id && result != :notification
+          { jsonrpc: "2.0", id: id, result: result }
+        else
+          nil
+        end
+      end
+
+      private
+
+      def handle_initialize(params)
+        @initialized = true
+
+        {
+          capabilities: {
+            textDocumentSync: {
+              openClose: true,
+              change: 1  # Full content sync
+            },
+            hoverProvider: true,
+            completionProvider: {
+              triggerCharacters: ["."],
+              resolveProvider: false
+            },
+            definitionProvider: true,
+            referencesProvider: true,
+            renameProvider: {
+              prepareProvider: true
+            }
+          },
+          serverInfo: {
+            name: "konpeito-lsp",
+            version: Konpeito::VERSION
+          }
+        }
+      end
+
+      def handle_shutdown
+        @initialized = false
+        nil
+      end
+
+      def handle_did_open(params)
+        uri = params.dig(:textDocument, :uri)
+        text = params.dig(:textDocument, :text)
+        @document_manager.open(uri, text)
+        :notification
+      end
+
+      def handle_did_change(params)
+        uri = params.dig(:textDocument, :uri)
+        # We use full sync, so first contentChanges has full text
+        changes = params[:contentChanges]
+        text = changes&.first&.dig(:text)
+        @document_manager.change(uri, text) if text
+        :notification
+      end
+
+      def handle_did_close(params)
+        uri = params.dig(:textDocument, :uri)
+        @document_manager.close(uri)
+        :notification
+      end
+
+      def handle_hover(params)
+        uri = params.dig(:textDocument, :uri)
+        position = params[:position]
+        @document_manager.hover(uri, position)
+      end
+
+      def handle_completion(params)
+        uri = params.dig(:textDocument, :uri)
+        position = params[:position]
+        @document_manager.completion(uri, position)
+      end
+
+      def handle_definition(params)
+        uri = params.dig(:textDocument, :uri)
+        position = params[:position]
+        @document_manager.definition(uri, position)
+      end
+
+      def handle_references(params)
+        uri = params.dig(:textDocument, :uri)
+        position = params[:position]
+        include_declaration = params.dig(:context, :includeDeclaration) != false
+        @document_manager.references(uri, position, include_declaration: include_declaration)
+      end
+
+      def handle_rename(params)
+        uri = params.dig(:textDocument, :uri)
+        position = params[:position]
+        new_name = params[:newName]
+        @document_manager.rename(uri, position, new_name)
+      end
+
+      def handle_prepare_rename(params)
+        uri = params.dig(:textDocument, :uri)
+        position = params[:position]
+        @document_manager.prepare_rename(uri, position)
+      end
+    end
+  end
+end

data/lib/konpeito/lsp/transport.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "language_server-protocol"
+
+module Konpeito
+  module LSP
+    # Handles LSP JSON-RPC communication over stdio
+    class Transport
+      def initialize(input: $stdin, output: $stdout)
+        @reader = LanguageServer::Protocol::Transport::Io::Reader.new(input)
+        @writer = LanguageServer::Protocol::Transport::Io::Writer.new(output)
+      end
+
+      # Read next request/notification from client
+      # @return [Hash, nil] The request object or nil if EOF
+      def read
+        @reader.read
+      end
+
+      # Write response to client
+      # @param response [Hash] The response object
+      def write(response)
+        @writer.write(response)
+      end
+
+      # Send notification to client (no response expected)
+      # @param method [String] The notification method
+      # @param params [Hash] The notification parameters
+      def notify(method, params)
+        @writer.write({
+          jsonrpc: "2.0",
+          method: method,
+          params: params
+        })
+      end
+    end
+  end
+end

data/lib/konpeito/parser/prism_adapter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Konpeito
+  module Parser
+    class PrismAdapter
+      class << self
+        def parse(source, filepath: "(eval)")
+          result = Prism.parse(source, filepath: filepath)
+
+          unless result.success?
+            errors = result.errors.map { |e| format_error(e, filepath) }
+            raise ParseError, "Parse errors:\n#{errors.join("\n")}"
+          end
+
+          result.value
+        end
+
+        def parse_file(filepath)
+          source = File.read(filepath)
+          parse(source, filepath: filepath)
+        end
+
+        # Detect require and require_relative calls in AST
+        # Returns array of { type: :require | :require_relative, name: String }
+        def detect_requires(ast)
+          requires = []
+          visitor = RequireVisitor.new(requires)
+          visitor.visit(ast)
+          requires
+        end
+
+        private
+
+        def format_error(error, filepath)
+          loc = error.location
+          "  #{filepath}:#{loc.start_line}:#{loc.start_column}: #{error.message}"
+        end
+      end
+
+      # Visitor to detect require/require_relative calls
+      class RequireVisitor < Prism::Visitor
+        def initialize(requires)
+          @requires = requires
+        end
+
+        def visit_call_node(node)
+          if node.receiver.nil? && %w[require require_relative].include?(node.name.to_s)
+            arg = node.arguments&.arguments&.first
+            if arg.is_a?(Prism::StringNode)
+              @requires << {
+                type: node.name.to_sym,
+                name: arg.unescaped,
+                line: node.location.start_line,
+                column: node.location.start_column
+              }
+            end
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/konpeito/platform.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Konpeito
+  module Platform
+    def self.windows?
+      !!(RbConfig::CONFIG["host_os"] =~ /mingw|mswin|cygwin/)
+    end
+
+    def self.macos?
+      !!(RbConfig::CONFIG["host_os"] =~ /darwin/)
+    end
+
+    def self.linux?
+      !!(RbConfig::CONFIG["host_os"] =~ /linux/)
+    end
+
+    # CRuby extension file extension
+    def self.shared_lib_extension
+      if macos? then ".bundle"
+      elsif windows? then ".dll"
+      else ".so"
+      end
+    end
+
+    # JVM classpath separator
+    def self.classpath_separator
+      windows? ? ";" : ":"
+    end
+
+    # Platform-independent executable finder (replaces `which`)
+    def self.find_executable(name)
+      exts = windows? ? (ENV["PATHEXT"] || ".COM;.EXE;.BAT").split(";") : [""]
+      ENV["PATH"].split(File::PATH_SEPARATOR).each do |dir|
+        exts.each do |ext|
+          path = File.join(dir, "#{name}#{ext}")
+          return path if File.executable?(path) && !File.directory?(path)
+        end
+      end
+      nil
+    end
+
+    # Find LLVM tool (clang, llc, opt) with version suffix fallback
+    def self.find_llvm_tool(name)
+      ["#{name}-20", "#{name}-19", "#{name}-18", name].each do |tool|
+        path = find_executable(tool)
+        return path if path
+      end
+      platform_llvm_paths(name).each { |p| return p if File.exist?(p) }
+      nil
+    end
+
+    # Find LLVM shared library for FFI (debug_info.rb)
+    def self.find_llvm_lib
+      candidates = if macos?
+        ["/opt/homebrew/opt/llvm@20/lib/libLLVM-20.dylib",
+         "/usr/local/opt/llvm@20/lib/libLLVM-20.dylib"]
+      elsif windows?
+        ["C:/Program Files/LLVM/bin/LLVM-C.dll"]
+      else
+        ["/usr/lib/llvm-20/lib/libLLVM-20.so", "/usr/lib/llvm-20/lib/libLLVM.so",
+         "/usr/lib64/llvm20/lib/libLLVM-20.so", "/usr/lib/libLLVM-20.so"]
+      end
+      candidates.find { |p| File.exist?(p) }
+    end
+
+    def self.default_java_home
+      if macos? then "/opt/homebrew/opt/openjdk@21"
+      elsif windows? then "C:/Program Files/Java/jdk-21"
+      else "/usr/lib/jvm/java-21-openjdk"
+      end
+    end
+
+    def self.java_install_hint
+      if macos? then "brew install openjdk@21"
+      elsif windows? then "winget install EclipseAdoptium.Temurin.21.JDK"
+      else "sudo apt install openjdk-21-jdk (Ubuntu) / sudo dnf install java-21-openjdk-devel (Fedora)"
+      end
+    end
+
+    def self.llvm_install_hint
+      if macos? then "brew install llvm@20"
+      elsif windows? then "winget install LLVM.LLVM"
+      else "sudo apt install llvm-20 clang-20 (Ubuntu) / sudo dnf install llvm20 clang20 (Fedora)"
+      end
+    end
+
+    def self.debugger_tune
+      macos? ? "lldb" : "gdb"
+    end
+
+    private_class_method def self.platform_llvm_paths(name)
+      if macos?
+        ["/opt/homebrew/opt/llvm@20/bin/#{name}", "/usr/local/opt/llvm@20/bin/#{name}"]
+      elsif windows?
+        ["C:/Program Files/LLVM/bin/#{name}.exe"]
+      else
+        ["/usr/lib/llvm-20/bin/#{name}", "/usr/lib/llvm-19/bin/#{name}", "/usr/bin/#{name}"]
+      end
+    end
+  end
+end

data/lib/konpeito/profile/report.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Konpeito
+  module Profile
+    # Represents profiling data for a single function
+    class FunctionProfile
+      attr_reader :name, :calls, :time_ms, :percent
+
+      def initialize(name:, calls:, time_ms:, percent:)
+        @name = name
+        @calls = calls
+        @time_ms = time_ms
+        @percent = percent
+      end
+
+      def to_h
+        {
+          name: @name,
+          calls: @calls,
+          time_ms: @time_ms,
+          percent: @percent
+        }
+      end
+    end
+
+    # Reads and formats profile reports from JSON files
+    class Report
+      attr_reader :functions, :total_time_ms
+
+      def initialize(json_path)
+        raise ArgumentError, "Profile file not found: #{json_path}" unless File.exist?(json_path)
+
+        @json_path = json_path
+        data = JSON.parse(File.read(json_path))
+        @functions = data["functions"].map do |f|
+          FunctionProfile.new(
+            name: f["name"],
+            calls: f["calls"],
+            time_ms: f["time_ms"],
+            percent: f["percent"]
+          )
+        end.sort_by { |f| -f.time_ms }
+        @total_time_ms = data["total_time_ms"]
+      end
+
+      def to_text(max_name_length: 40)
+        lines = []
+        lines << "Konpeito Profile Report"
+        lines << "=" * 76
+        lines << ""
+        lines << format("%-#{max_name_length}s %12s %12s %8s", "Function", "Calls", "Time (ms)", "%")
+        lines << format("%-#{max_name_length}s %12s %12s %8s",
+                        "-" * max_name_length, "-" * 12, "-" * 12, "-" * 8)
+
+        @functions.each do |f|
+          name = truncate_name(f.name, max_name_length)
+          lines << format("%-#{max_name_length}s %12d %12.3f %7.2f%%",
+                          name, f.calls, f.time_ms, f.percent)
+        end
+
+        lines << ""
+        lines << "Total time: #{@total_time_ms.round(3)} ms"
+        lines.join("\n")
+      end
+
+      def to_json_pretty
+        JSON.pretty_generate({
+          functions: @functions.map(&:to_h),
+          total_time_ms: @total_time_ms
+        })
+      end
+
+      def hottest_functions(n = 5)
+        @functions.first(n)
+      end
+
+      def most_called_functions(n = 5)
+        @functions.sort_by { |f| -f.calls }.first(n)
+      end
+
+      # Get the path to the flame graph folded file
+      def flame_graph_path
+        @json_path.sub(/\.json$/, ".folded")
+      end
+
+      # Check if flame graph data exists
+      def flame_graph_available?
+        File.exist?(flame_graph_path)
+      end
+
+      # Read flame graph data as array of [stack, samples]
+      def flame_graph_stacks
+        return [] unless flame_graph_available?
+
+        File.readlines(flame_graph_path).map do |line|
+          parts = line.strip.split(" ")
+          samples = parts.pop.to_i
+          stack = parts.join(" ")
+          [stack, samples]
+        end.sort_by { |_, samples| -samples }
+      end
+
+      # Generate flame graph text summary
+      def flame_graph_summary(max_stacks: 10)
+        stacks = flame_graph_stacks.first(max_stacks)
+        return "No flame graph data available" if stacks.empty?
+
+        lines = []
+        lines << "Flame Graph Stack Summary (Top #{max_stacks})"
+        lines << "=" * 76
+        lines << ""
+
+        total_samples = flame_graph_stacks.sum { |_, s| s }
+        stacks.each do |stack, samples|
+          percent = total_samples > 0 ? (samples * 100.0 / total_samples) : 0
+          lines << format("%7d (%5.1f%%) %s", samples, percent, stack)
+        end
+
+        lines << ""
+        lines << "To generate flame graph SVG:"
+        lines << "  flamegraph.pl #{flame_graph_path} > profile.svg"
+        lines.join("\n")
+      end
+
+      private
+
+      def truncate_name(name, max_length)
+        return name if name.length <= max_length
+
+        "#{name[0, max_length - 3]}..."
+      end
+    end
+  end
+end