kaisoku 0.1.0

data/lib/kaisoku/evaluator/report.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Evaluator
+    class Report
+      def initialize(results)
+        @results = results
+      end
+
+      def render
+        [
+          "=== Kaisoku Evaluation Report (#{@results.length} commits) ===",
+          "Safety violations : #{safety_violations}",
+          "Selection ratio   : #{format('%.1f%%', selection_ratio * 100)}",
+          "Reduction ratio   : #{format('%.1f%%', reduction_ratio * 100)}",
+          "Precision         : #{format('%.1f%%', precision * 100)}",
+          "APFD              : #{format('%.2f', apfd)}",
+          "E2E time ratio    : #{format('%.1f%%', e2e_time_ratio * 100)}",
+          "Fallback commits  : #{fallback_count}/#{@results.length}",
+          diagnostics
+        ].join("\n")
+      end
+
+      def to_h
+        {
+          commit_count: @results.length,
+          safety_violations: safety_violations,
+          selection_ratio: selection_ratio,
+          reduction_ratio: reduction_ratio,
+          precision: precision,
+          apfd: apfd,
+          e2e_time_ratio: e2e_time_ratio,
+          fallback_count: fallback_count,
+          commits: @results.map { |result| result_payload(result) }
+        }
+      end
+
+      def safe?
+        safety_violations.zero?
+      end
+
+      private
+
+      def safety_violations
+        @results.sum { |result| Array(result.safety_violations).length }
+      end
+
+      def precision
+        return 1.0 if @results.empty?
+
+        @results.sum { |result| result.precision || 1.0 } / @results.length
+      end
+
+      def selection_ratio
+        median(selection_ratios)
+      end
+
+      def reduction_ratio
+        ratios = selection_ratios
+        return 0.0 if ratios.empty?
+
+        1.0 - median(ratios)
+      end
+
+      def e2e_time_ratio
+        full = @results.sum(&:full_time)
+        return 0.0 if full.zero?
+
+        @results.sum(&:selected_time) / full
+      end
+
+      def apfd
+        return 1.0 if @results.empty?
+
+        @results.sum { |result| result.apfd || 1.0 } / @results.length
+      end
+
+      def fallback_count
+        @results.count(&:fallback)
+      end
+
+      def diagnostics
+        violations = @results.select { |result| Array(result.safety_violations).any? }
+        return 'Diagnostics       : none' if violations.empty?
+
+        lines = violations.flat_map do |result|
+          result.safety_violations.map { |id| "#{result.commit}: missed #{id}" }
+        end
+        "Diagnostics       :\n#{lines.join("\n")}"
+      end
+
+      def result_payload(result)
+        {
+          commit: result.commit,
+          full_status: result.full_status,
+          selected_status: result.selected_status,
+          full_time: result.full_time,
+          selected_time: result.selected_time,
+          fallback: result.fallback,
+          safety_violations: Array(result.safety_violations),
+          precision: result.precision,
+          apfd: result.apfd,
+          changed_files: Array(result.changed_files),
+          selected_count: result.selected_count,
+          total_count: result.total_count
+        }
+      end
+
+      def median(values)
+        return 0.0 if values.empty?
+
+        sorted = values.sort
+        middle = sorted.length / 2
+        return sorted[middle] if sorted.length.odd?
+
+        (sorted[middle - 1] + sorted[middle]) / 2.0
+      end
+
+      def selection_ratios
+        @results.filter_map do |result|
+          next unless result.total_count.to_i.positive?
+
+          result.selected_count.to_f / result.total_count
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/hybrid_policy.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class HybridPolicy
+    def initialize(test_map:, configuration:)
+      @test_map = test_map
+      @configuration = configuration
+    end
+
+    def method_level?(path)
+      @test_map.dependency_entity_count(path, adapter: @configuration.adapter) >= @configuration.method_level_threshold
+    end
+  end
+end

data/lib/kaisoku/listen_watcher.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'listen'
+
+module Kaisoku
+  class ListenWatcher
+    DEFAULT_PATHS = Watcher::DEFAULT_PATHS
+    attr_reader :configuration, :paths
+
+    def initialize(configuration: Configuration.new, paths: DEFAULT_PATHS, interval: 0.2)
+      @configuration = configuration
+      @paths = Array(paths).empty? ? DEFAULT_PATHS : Array(paths)
+      @interval = interval
+    end
+
+    def each_change
+      listener = Listen.to(*existing_paths, latency: @interval) do |modified, added, removed|
+        changed = (modified + added + removed).map { |path| configuration.relative_path(path) }.sort
+        yield changed unless changed.empty?
+      end
+      listener.start
+      sleep
+    ensure
+      listener&.stop
+    end
+
+    private
+
+    def existing_paths
+      found = paths.map { |path| configuration.absolute_path(path) }.select { |path| File.exist?(path) }
+      found.empty? ? [configuration.project_root] : found
+    end
+  end
+end

data/lib/kaisoku/lsp/message_io.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kaisoku
+  module LSP
+    class MessageIO
+      def initialize(input: $stdin, output: $stdout)
+        @input = input
+        @output = output
+      end
+
+      def read
+        headers = read_headers
+        length = headers['content-length'].to_i
+        return nil if length.zero?
+
+        JSON.parse(@input.read(length))
+      end
+
+      def write(payload)
+        json = JSON.generate(payload)
+        @output.write("Content-Length: #{json.bytesize}\r\n\r\n#{json}")
+        @output.flush
+      end
+
+      private
+
+      def read_headers
+        headers = {}
+        while (line = @input.gets)
+          line = line.strip
+          break if line.empty?
+
+          key, value = line.split(/:\s*/, 2)
+          headers[key.downcase] = value
+        end
+        headers
+      end
+    end
+  end
+end

data/lib/kaisoku/lsp/server.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Kaisoku
+  module LSP
+    class Server
+      def initialize(configuration: Configuration.new, io: MessageIO.new)
+        @configuration = configuration
+        @io = io
+      end
+
+      def start
+        while (message = @io.read)
+          handle(message)
+        end
+      end
+
+      private
+
+      def handle(message)
+        case message['method']
+        when 'initialize'
+          respond(message['id'], capabilities)
+        when 'shutdown'
+          respond(message['id'], nil)
+        when 'textDocument/didSave'
+          publish_diagnostics(message)
+        when 'textDocument/codeLens'
+          respond(message['id'], code_lenses(message))
+        end
+      end
+
+      def respond(id, result)
+        @io.write(jsonrpc: '2.0', id: id, result: result)
+      end
+
+      def publish_diagnostics(message)
+        uri = message.dig('params', 'textDocument', 'uri')
+        selection = selection_for(uri_to_path(uri))
+        @io.write(
+          jsonrpc: '2.0',
+          method: 'textDocument/publishDiagnostics',
+          params: { uri: uri, diagnostics: diagnostics(selection) }
+        )
+      end
+
+      def selection_for(path)
+        context = RuntimeContext.new(adapter: @configuration.adapter, project_root: @configuration.project_root)
+        Selector.new(test_map: context.test_map, configuration: @configuration).select(
+          changed_paths: [path],
+          all_entities: context.adapter.discover
+        )
+      end
+
+      def diagnostics(selection)
+        [{
+          severity: selection.safe? ? 3 : 2,
+          source: 'kaisoku',
+          message: "selected #{selection.count} test entities: #{selection.reason}",
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 0 }
+          }
+        }]
+      end
+
+      def code_lenses(message)
+        uri = message.dig('params', 'textDocument', 'uri')
+        selection = selection_for(uri_to_path(uri))
+        [{
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 0 }
+          },
+          command: {
+            title: "Kaisoku: #{selection.count} selected test entities",
+            command: 'kaisoku.showSelection',
+            arguments: [selection.entities.map(&:id), selection.reason]
+          }
+        }]
+      end
+
+      def capabilities
+        {
+          capabilities: {
+            textDocumentSync: { save: true },
+            codeLensProvider: { resolveProvider: false }
+          }
+        }
+      end
+
+      def uri_to_path(uri)
+        return uri unless uri&.start_with?('file://')
+
+        URI.decode_www_form_component(uri.sub('file://', ''))
+      end
+    end
+  end
+end

data/lib/kaisoku/method_map.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'prism'
+
+module Kaisoku
+  class MethodMap
+    TOP_LEVEL = '__toplevel__'
+
+    def initialize(configuration: Configuration.new)
+      @configuration = configuration
+    end
+
+    def checksums(path)
+      absolute = @configuration.absolute_path(path)
+      return {} unless File.file?(absolute) && File.extname(absolute) == '.rb'
+
+      source = File.read(absolute)
+      lines = source.lines
+      ranges = method_ranges(source)
+      ranges.to_h do |name, range|
+        ["#{@configuration.relative_path(path)}##{name}", digest(lines[(range.begin - 1)..(range.end - 1)].join)]
+      end.merge(top_level_checksum(path, lines, ranges.values))
+    rescue StandardError
+      {}
+    end
+
+    def keys_for_lines(path, touched_lines)
+      absolute = @configuration.absolute_path(path)
+      return [] unless File.file?(absolute) && File.extname(absolute) == '.rb'
+
+      ranges = method_ranges(File.read(absolute))
+      touched = Array(touched_lines).map(&:to_i)
+      keys = ranges.filter_map do |name, range|
+        "#{@configuration.relative_path(path)}##{name}" if touched.any? { |line| range.cover?(line) }
+      end
+      keys << "#{@configuration.relative_path(path)}##{TOP_LEVEL}" if top_level_touched?(touched, ranges.values)
+      keys
+    rescue StandardError
+      []
+    end
+
+    private
+
+    def method_ranges(source)
+      nodes(Prism.parse(source).value).each_with_object({}) do |node, ranges|
+        next unless node.is_a?(Prism::DefNode)
+
+        ranges[node.name.to_s] = node.location.start_line..node.location.end_line
+      end
+    end
+
+    def nodes(root, &block)
+      return enum_for(:nodes, root) unless block_given?
+
+      yield root
+      root.child_nodes.compact.each { |child| nodes(child, &block) } if root.respond_to?(:child_nodes)
+    end
+
+    def top_level_checksum(path, lines, ranges)
+      top_lines = lines.each_with_index.filter_map do |line, index|
+        line unless ranges.any? { |range| range.cover?(index + 1) }
+      end
+      { "#{@configuration.relative_path(path)}##{TOP_LEVEL}" => digest(top_lines.join) }
+    end
+
+    def top_level_touched?(touched_lines, ranges)
+      touched_lines.any? { |line| ranges.none? { |range| range.cover?(line) } }
+    end
+
+    def digest(source)
+      Digest::SHA256.hexdigest(source)
+    end
+  end
+end

data/lib/kaisoku/preload/client.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'msgpack'
+require 'socket'
+
+module Kaisoku
+  module Preload
+    class Client
+      def initialize(socket_path:)
+        @socket_path = socket_path
+      end
+
+      def request(command, payload = {})
+        UNIXSocket.open(@socket_path) do |socket|
+          socket.write(MessagePack.pack(payload.merge('command' => command)))
+          socket.close_write
+          MessagePack.unpack(socket.read)
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/preload/daemon.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'msgpack'
+require 'socket'
+
+module Kaisoku
+  module Preload
+    class Daemon
+      def initialize(socket_path:, server:)
+        @socket_path = socket_path
+        @server = server
+      end
+
+      def start
+        FileUtils.mkdir_p(File.dirname(@socket_path))
+        FileUtils.rm_f(@socket_path)
+        UNIXServer.open(@socket_path) { |socket| loop { handle(socket.accept) } }
+      ensure
+        File.unlink(@socket_path) if @socket_path && File.socket?(@socket_path)
+      end
+
+      private
+
+      def handle(socket)
+        request = MessagePack.unpack(socket.read)
+        response = dispatch(request)
+        socket.write(MessagePack.pack(response))
+      rescue StandardError => e
+        socket.write(MessagePack.pack('ok' => false, 'error' => "#{e.class}: #{e.message}"))
+      ensure
+        socket.close
+      end
+
+      def dispatch(request)
+        case request['command']
+        when 'status'
+          { 'ok' => true, 'status' => @server.status }
+        when 'refresh'
+          changed = Array(request['changed_paths'])
+          { 'ok' => true, 'refreshed' => @server.refresh_if_needed(changed), 'status' => @server.status }
+        else
+          { 'ok' => false, 'error' => 'unknown preload command' }
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/preload/fallback_runner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Preload
+    class FallbackRunner
+      def initialize(preload_server:)
+        @preload_server = preload_server
+      end
+
+      def run(&)
+        return yield if @preload_server.disabled?
+
+        preload_result = @preload_server.run(&)
+        return preload_result unless suspicious_result?(preload_result)
+
+        cold_result = yield
+        disable_if_different(preload_result, cold_result)
+        cold_result
+      rescue StandardError => e
+        @preload_server.disable!("preload failed: #{e.class}: #{e.message}")
+        yield
+      end
+
+      private
+
+      def suspicious_result?(result)
+        Array(result).any? do |item|
+          item.respond_to?(:error) && item.error.to_s.match?(/Bootsnap|LoadError|NameError|Zeitwerk|ActiveRecord/)
+        end
+      end
+
+      def disable_if_different(preload_result, cold_result)
+        return if signature(preload_result) == signature(cold_result)
+
+        @preload_server.disable!('preload result differed from cold run')
+      end
+
+      def signature(result)
+        Array(result).map do |item|
+          item.respond_to?(:status) ? [item.entity&.id, item.status, item.error] : item
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/preload/server.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module Kaisoku
+  module Preload
+    class Server
+      attr_reader :generation, :last_restart_reason, :last_heartbeat_at, :worker_failures, :disabled_reason
+
+      def initialize(configuration: Configuration.new, checksum: Checksum.new)
+        @configuration = configuration
+        @checksum = checksum
+        @generation = 0
+        @last_restart_reason = 'initial boot'
+        @last_heartbeat_at = nil
+        @worker_failures = 0
+        @disabled_reason = nil
+        @loaded_checksums = {}
+        boot!
+      end
+
+      def boot!
+        @generation += 1
+        heartbeat!
+        @loaded_checksums = loaded_file_checksums
+      end
+
+      def stale_for?(changed_paths)
+        Array(changed_paths).any? do |path|
+          relative = @configuration.relative_path(path)
+          @configuration.boot_impact_file?(relative) || loaded_file_changed?(relative)
+        end
+      end
+
+      def refresh_if_needed(changed_paths)
+        return false if disabled?
+        return false unless stale_for?(changed_paths)
+
+        @last_restart_reason = "changed: #{Array(changed_paths).join(', ')}"
+        boot!
+        true
+      end
+
+      def run
+        raise Error, "preload disabled: #{disabled_reason}" if disabled?
+
+        refresh_if_needed([])
+        heartbeat!
+        reader, writer = IO.pipe
+        pid = fork do
+          begin
+            reader.close
+            Marshal.dump(yield, writer)
+          ensure
+            writer.close
+          end
+          exit! 0
+        end
+        writer.close
+        result = Marshal.load(reader)
+        Process.wait(pid)
+        if $CHILD_STATUS.success?
+          @worker_failures = 0
+          heartbeat!
+          return result
+        end
+
+        @worker_failures += 1
+        @last_restart_reason = "worker failure: status #{$CHILD_STATUS.exitstatus}"
+        boot!
+        raise Error, "preload worker exited with status #{$CHILD_STATUS.exitstatus}"
+      rescue StandardError
+        raise
+      ensure
+        reader&.close
+      end
+
+      def status
+        {
+          generation: generation,
+          loaded_files: @loaded_checksums.length,
+          last_restart_reason: last_restart_reason,
+          last_heartbeat_at: last_heartbeat_at,
+          worker_failures: worker_failures,
+          disabled_reason: disabled_reason,
+          healthy: !disabled?
+        }
+      end
+
+      def disable!(reason)
+        @disabled_reason = reason
+        @last_restart_reason = reason
+      end
+
+      def disabled?
+        !disabled_reason.nil?
+      end
+
+      private
+
+      def heartbeat!
+        @last_heartbeat_at = Time.now.to_i
+      end
+
+      def loaded_file_changed?(relative)
+        return false unless @loaded_checksums.key?(relative)
+
+        current = @checksum.digest(@configuration.absolute_path(relative))
+        current != @loaded_checksums[relative]
+      end
+
+      def loaded_file_checksums
+        $LOADED_FEATURES.each_with_object({}) do |file, checksums|
+          absolute = File.expand_path(file)
+          next unless @configuration.project_file?(absolute)
+
+          digest = @checksum.digest(absolute)
+          checksums[@configuration.relative_path(absolute)] = digest if digest
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/preload/socket_path.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Preload
+    module SocketPath
+      module_function
+
+      def default(configuration)
+        File.join(configuration.project_root, '.kaisoku', 'preload.sock')
+      end
+    end
+  end
+end

data/lib/kaisoku/prioritizer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class Prioritizer
+    def order(entities)
+      entities.sort_by do |entity|
+        [
+          entity.failed? ? 0 : 1,
+          -(entity.last_failed_at || 0),
+          -entity.failure_count.to_i,
+          entity.avg_duration_ms || Float::INFINITY,
+          entity.file,
+          entity.identifier
+        ]
+      end
+    end
+  end
+end