kward 0.66.0

data/lib/kward/rpc/tool_event_normalizer.rb

@@ -0,0 +1,68 @@
+require "time"
+require_relative "tool_metadata"
+
+module Kward
+  module RPC
+    class ToolEventNormalizer
+      def initialize(tool_call, content: nil)
+        @tool_call = tool_call
+        @content = content
+        @fields = ToolMetadata.normalized_tool_fields(@tool_call)
+      end
+
+      def call_payload(legacy_tool: nil)
+        {
+          toolCall: @tool_call,
+          rawToolCall: @tool_call,
+          tool: legacy_tool,
+          toolCallId: @fields[:toolCallId],
+          toolName: @fields[:toolName],
+          args: @fields[:args]
+        }.compact
+      end
+
+      def result_payload(legacy_tool: nil)
+        call_payload(legacy_tool: legacy_tool).merge(
+          content: @content,
+          result: normalized_result
+        )
+      end
+
+      def execution_record(timestamp: Time.now.utc.iso8601(3))
+        result = normalized_result
+        {
+          type: "tool_execution_end",
+          timestamp: timestamp,
+          toolCallId: @fields[:toolCallId],
+          toolName: @fields[:toolName],
+          args: @fields[:args],
+          result: result,
+          isError: result[:isError]
+        }
+      end
+
+      private
+
+      def normalized_result
+        text = @content.to_s
+        is_error = ToolMetadata.error_result?(text)
+        result = { content: text, isError: is_error, images: [] }
+        unless is_error
+          diff = ToolMetadata.extract_unified_diff(text)
+          result[:diff] = diff if diff
+
+          files = changed_files
+          result[:changedFiles] = files if files.any?
+        end
+        result
+      end
+
+      def changed_files
+        return [] unless ["edit", "write"].include?(@fields[:toolName])
+
+        path = @fields.dig(:args, :path)
+        path.to_s.empty? ? [] : [path]
+      end
+    end
+  end
+end

data/lib/kward/rpc/tool_metadata.rb

@@ -0,0 +1,80 @@
+require_relative "../tools/tool_call"
+require_relative "../workspace"
+
+module Kward
+  module RPC
+    module ToolMetadata
+      module_function
+
+      def normalized_tool_fields(tool_call)
+        raw_name = ToolCall.name(tool_call)
+        args = ToolCall.arguments(tool_call)
+        {
+          toolCallId: ToolCall.id(tool_call),
+          toolName: normalize_tool_name(raw_name) || raw_name,
+          args: normalize_tool_args(raw_name, args)
+        }.compact
+      end
+
+      def normalize_tool_name(name)
+        ToolCall.normalized_name(name)
+      end
+
+      def normalize_tool_args(name, args)
+        case name.to_s
+        when "edit_file", "edit"
+          normalize_edit_args(args)
+        when "write_file", "write"
+          normalize_write_args(args)
+        when "run_shell_command", "bash"
+          normalize_bash_args(args)
+        else
+          ToolCall.camelize_args(args)
+        end
+      end
+
+      def normalize_edit_args(args)
+        result = {}
+        path = ToolCall.value(args, :path)
+        result[:path] = path if path
+        edits = Array(ToolCall.value(args, :edits)).filter_map do |edit|
+          next unless edit.is_a?(Hash)
+
+          {
+            oldText: ToolCall.value(edit, :oldText) || ToolCall.value(edit, :old_text),
+            newText: ToolCall.value(edit, :newText) || ToolCall.value(edit, :new_text)
+          }.compact
+        end
+        result[:edits] = edits if edits.any?
+        result
+      end
+
+      def normalize_write_args(args)
+        result = {}
+        path = ToolCall.value(args, :path)
+        content = ToolCall.value(args, :content)
+        result[:path] = path if path
+        result[:content] = content if content
+        result
+      end
+
+      def normalize_bash_args(args)
+        result = {}
+        command = ToolCall.value(args, :command)
+        timeout = ToolCall.value(args, :timeout) || ToolCall.value(args, :timeout_seconds) || Workspace::DEFAULT_COMMAND_TIMEOUT_SECONDS
+        result[:command] = command if command
+        result[:timeout] = timeout if timeout
+        result
+      end
+
+      def extract_unified_diff(text)
+        index = text.to_s.index(/^--- /)
+        index ? text.to_s[index..] : nil
+      end
+
+      def error_result?(text)
+        text.to_s.start_with?("Error:", "Declined:", "Cancelled.")
+      end
+    end
+  end
+end

data/lib/kward/rpc/transcript_normalizer.rb

@@ -0,0 +1,307 @@
+require_relative "../tools/tool_call"
+require_relative "tool_metadata"
+
+module Kward
+  module RPC
+    class TranscriptNormalizer
+      IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"].freeze
+      THINKING_CONTENT_TYPES = ["thinking", "reasoning"].freeze
+
+      def initialize(messages)
+        @messages = Array(messages)
+        @tool_calls_by_id = {}
+      end
+
+      def normalize
+        @messages.filter_map { |message| normalize_message(message) }
+      end
+
+      private
+
+      def normalize_message(message)
+        return nil unless message.is_a?(Hash)
+
+        case value(message, :role).to_s
+        when "system"
+          nil
+        when "user"
+          normalize_user_message(message)
+        when "assistant"
+          normalize_assistant_message(message)
+        when "tool"
+          normalize_tool_result_message(message)
+        when "toolResult"
+          normalize_tool_result_message(message)
+        when "compactionSummary"
+          normalize_compaction_summary(message)
+        when "branchSummary", "custom"
+          message
+        else
+          nil
+        end
+      end
+
+      def normalize_compaction_summary(message)
+        summary = value(message, :summary) || value(message, :content)
+        result = { role: "compactionSummary", summary: summary.to_s }
+        tokens_before = value(message, :tokensBefore) || value(message, :tokens_before)
+        result[:tokensBefore] = tokens_before if tokens_before
+        result
+      end
+
+      def normalize_user_message(message)
+        {
+          role: "user",
+          content: normalize_content(value(message, :content))
+        }
+      end
+
+      def normalize_assistant_message(message)
+        content = reasoning_first_content(normalize_content(value(message, :content), preserve_thinking: true))
+        reasoning = normalize_reasoning_summary(message)
+        content.unshift(reasoning) if reasoning && !thinking_content?(content)
+        tool_calls(message).each do |tool_call|
+          normalized_tool_call = normalize_tool_call(tool_call)
+          next unless normalized_tool_call
+
+          @tool_calls_by_id[normalized_tool_call[:id]] = normalized_tool_call if normalized_tool_call[:id]
+          content << normalized_tool_call
+        end
+
+        result = { role: "assistant", content: content }
+        error_message = value(message, :errorMessage) || value(message, :error_message)
+        result[:errorMessage] = error_message unless error_message.to_s.empty?
+        result
+      end
+
+      def normalize_tool_result_message(message)
+        tool_call_id = value(message, :toolCallId) || value(message, :tool_call_id)
+        matching_call = @tool_calls_by_id[tool_call_id]
+        raw_name = value(message, :toolName) || value(message, :tool_name) || value(message, :name)
+        tool_name = normalize_tool_name(raw_name) || raw_name || matching_call&.dig(:name)
+        content = normalize_content(value(message, :content))
+
+        result = {
+          role: "toolResult",
+          toolCallId: tool_call_id,
+          isError: error_tool_result?(message, content),
+          content: content
+        }.compact
+        result[:toolName] = tool_name if tool_name
+
+        details = tool_result_details(message, matching_call, content)
+        result[:details] = details unless details.empty?
+        result
+      end
+
+      def normalize_tool_call(tool_call)
+        return nil unless tool_call.is_a?(Hash)
+
+        raw_name = ToolCall.name(tool_call)
+        {
+          type: "toolCall",
+          id: ToolCall.id(tool_call),
+          name: normalize_tool_name(raw_name) || raw_name,
+          arguments: normalize_tool_arguments(raw_name, ToolCall.raw_arguments(tool_call))
+        }.compact
+      end
+
+      def normalize_content(content, preserve_thinking: false)
+        case content
+        when Array
+          content.filter_map { |part| normalize_content_part(part, preserve_thinking: preserve_thinking) }
+        when nil
+          []
+        else
+          [{ type: "text", text: content.to_s }]
+        end
+      end
+
+      def normalize_content_part(part, preserve_thinking: false)
+        return { type: "text", text: part.to_s } unless part.is_a?(Hash)
+
+        type = value(part, :type).to_s
+        case type
+        when "text"
+          text = value(part, :text)
+          text.nil? ? nil : { type: "text", text: text.to_s }
+        when "image"
+          normalize_image_part(part)
+        when "toolCall"
+          normalize_existing_tool_call_part(part)
+        when *THINKING_CONTENT_TYPES
+          preserve_thinking ? normalize_thinking_part(part) : normalize_unknown_content_part(part)
+        else
+          normalize_unknown_content_part(part)
+        end
+      end
+
+      def normalize_unknown_content_part(part)
+        text = value(part, :text)
+        text.nil? ? nil : { type: "text", text: text.to_s }
+      end
+
+      def normalize_thinking_part(part)
+        thinking = value(part, :thinking) || value(part, :reasoning) || value(part, :text)
+        thinking.nil? ? nil : { type: "thinking", thinking: thinking.to_s }
+      end
+
+      def normalize_reasoning_summary(message)
+        summary = value(message, :reasoning_summary) || value(message, :reasoningSummary)
+        summary.to_s.empty? ? nil : { type: "thinking", thinking: summary.to_s }
+      end
+
+      def thinking_content?(content)
+        content.any? { |part| thinking_content_part?(part) }
+      end
+
+      def reasoning_first_content(content)
+        thinking, other = content.partition { |part| thinking_content_part?(part) }
+        thinking.empty? ? content : thinking + other
+      end
+
+      def thinking_content_part?(part)
+        part.is_a?(Hash) && value(part, :type) == "thinking"
+      end
+
+      def normalize_image_part(part)
+        mime_type = value(part, :mimeType) || value(part, :mime_type) || value(part, :media_type)
+        mime_type = normalize_mime_type(mime_type)
+        return nil unless IMAGE_MIME_TYPES.include?(mime_type)
+
+        data = value(part, :data)
+        return nil if data.to_s.empty?
+
+        result = { type: "image", data: data, mimeType: mime_type }
+        alt = value(part, :alt) || image_alt_from_path(value(part, :path))
+        result[:alt] = alt unless alt.to_s.empty?
+        result
+      end
+
+      def normalize_existing_tool_call_part(part)
+        raw_name = value(part, :name)
+        arguments = value(part, :arguments) || {}
+        {
+          type: "toolCall",
+          id: value(part, :id),
+          name: normalize_tool_name(raw_name) || raw_name,
+          arguments: normalize_tool_arguments(raw_name, arguments)
+        }.compact
+      end
+
+      def tool_result_details(message, matching_call, content)
+        explicit_details = value(message, :details)
+        details = explicit_details.is_a?(Hash) ? safe_details(explicit_details) : {}
+        text = content_text(content)
+
+        diff = details[:diff] || details["diff"] || extract_unified_diff(text)
+        details[:diff] = diff if diff
+
+        changed_files = details[:changedFiles] || details["changedFiles"] || changed_files_from_result(text, matching_call)
+        details[:changedFiles] = changed_files if changed_files && !changed_files.empty?
+
+        details
+      end
+
+      def safe_details(details)
+        allowed = {}
+        diff = value(details, :diff)
+        allowed[:diff] = diff if diff
+        changed_files = value(details, :changedFiles) || value(details, :changed_files)
+        allowed[:changedFiles] = changed_files if changed_files.is_a?(Array)
+        allowed
+      end
+
+      def extract_unified_diff(text)
+        ToolMetadata.extract_unified_diff(text)
+      end
+
+      def changed_files_from_result(text, matching_call)
+        path = matching_call&.dig(:arguments, :path) || matching_call&.dig(:arguments, "path")
+        return [path] if path
+
+        if (match = text.match(/\A(?:Wrote \d+ bytes to|Edited)\s+([^:\n]+)/))
+          [match[1].strip]
+        else
+          []
+        end
+      end
+
+      def error_tool_result?(message, content)
+        return value(message, :isError) if has_key?(message, :isError)
+        return value(message, :is_error) if has_key?(message, :is_error)
+
+        ToolMetadata.error_result?(content_text(content))
+      end
+
+      def content_text(content)
+        Array(content).filter_map do |part|
+          part[:text] || part["text"] if part.is_a?(Hash)
+        end.join("\n")
+      end
+
+      def tool_calls(message)
+        calls = value(message, :tool_calls) || value(message, :toolCalls)
+        calls.is_a?(Array) ? calls : []
+      end
+
+      def normalize_tool_name(name)
+        ToolMetadata.normalize_tool_name(name)
+      end
+
+      def normalize_tool_arguments(name, arguments)
+        args = ToolCall.parse_arguments(arguments)
+        case name.to_s
+        when "edit_file", "edit"
+          normalize_edit_args(args)
+        when "run_shell_command", "bash"
+          normalize_bash_args(args)
+        else
+          camelize_tool_args(args)
+        end
+      end
+
+      def normalize_edit_args(args)
+        normalized = camelize_tool_args(args)
+        edits = Array(value(args, :edits)).filter_map do |edit|
+          next unless edit.is_a?(Hash)
+
+          {
+            oldText: value(edit, :oldText) || value(edit, :old_text),
+            newText: value(edit, :newText) || value(edit, :new_text)
+          }.compact
+        end
+        normalized[:edits] = edits if edits.any?
+        normalized
+      end
+
+      def normalize_bash_args(args)
+        normalized = camelize_tool_args(args)
+        timeout = value(args, :timeoutSeconds) || value(args, :timeout_seconds)
+        normalized[:timeoutSeconds] = timeout if timeout
+        normalized.delete(:timeout_seconds)
+        normalized
+      end
+
+      def camelize_tool_args(args)
+        ToolCall.camelize_args(args)
+      end
+
+      def normalize_mime_type(mime_type)
+        mime_type.to_s.downcase.sub("image/jpg", "image/jpeg")
+      end
+
+      def image_alt_from_path(path)
+        path ? File.basename(path.to_s) : nil
+      end
+
+      def value(object, key)
+        ToolCall.value(object, key)
+      end
+
+      def has_key?(object, key)
+        object.respond_to?(:key?) && (object.key?(key) || object.key?(key.to_s))
+      end
+    end
+  end
+end

data/lib/kward/rpc/transport.rb

@@ -0,0 +1,58 @@
+require "json"
+
+module Kward
+  module RPC
+    class Transport
+      def initialize(input:, output:)
+        @input = input
+        @output = output
+        @write_mutex = Mutex.new
+      end
+
+      def read_message
+        headers = read_headers
+        return nil unless headers
+
+        length = headers["content-length"].to_i
+        raise "Missing Content-Length header" if length <= 0
+
+        body = @input.read(length)
+        raise "Unexpected EOF while reading JSON-RPC body" unless body && body.bytesize == length
+
+        JSON.parse(body)
+      end
+
+      def write_message(message)
+        body = JSON.generate(message)
+        @write_mutex.synchronize do
+          @output.write("Content-Length: #{body.bytesize}\r\n\r\n")
+          @output.write(body)
+          @output.flush if @output.respond_to?(:flush)
+        end
+      end
+
+      private
+
+      def read_headers
+        headers = {}
+        saw_header = false
+
+        loop do
+          line = @input.gets
+          return nil unless line
+
+          line = line.delete_suffix("\n").delete_suffix("\r")
+          break if line.empty?
+
+          saw_header = true
+          name, value = line.split(":", 2)
+          raise "Invalid JSON-RPC header: #{line}" unless name && value
+
+          headers[name.downcase] = value.strip
+        end
+
+        saw_header ? headers : nil
+      end
+    end
+  end
+end

data/lib/kward/session_diff.rb

@@ -0,0 +1,125 @@
+require "json"
+
+module Kward
+  class SessionDiff
+    attr_reader :additions, :deletions
+
+    def initialize(additions: 0, deletions: 0)
+      @additions = additions.to_i
+      @deletions = deletions.to_i
+    end
+
+    def self.from_session_file(path)
+      records = File.readlines(path, chomp: true).filter_map { |line| parse_record(line) }
+      from_records(records)
+    rescue Errno::ENOENT, Errno::EACCES
+      new
+    end
+
+    def self.from_records(records)
+      execution_records = records.select { |record| record["type"] == "tool_execution_end" }
+      source_records = execution_records.empty? ? records : execution_records
+      source_records.each_with_object(new) do |record, diff|
+        if record["type"] == "tool_execution_end"
+          next if record["isError"] || record.dig("result", "isError")
+
+          diff.add_diff(record.dig("result", "diff"))
+        elsif record["type"] == "message" && (record.dig("message", "role") == "tool" || record.dig("message", :role) == "tool")
+          diff.add_tool_result(record.dig("message", "content") || record.dig("message", :content))
+        end
+      end
+    end
+
+    def self.count(diff)
+      if (stats = truncated_diff_stats(diff))
+        return stats
+      elsif truncated_diff?(diff)
+        return { additions: 0, deletions: 0 }
+      end
+
+      additions = 0
+      deletions = 0
+      removed = []
+      added = []
+      flush = lambda do
+        common = common_line_count(removed, added)
+        additions += added.length - common
+        deletions += removed.length - common
+        removed.clear
+        added.clear
+      end
+
+      diff.to_s.each_line do |line|
+        if line.start_with?("+") && !line.start_with?("+++")
+          added << line[1..]
+        elsif line.start_with?("-") && !line.start_with?("---")
+          removed << line[1..]
+        else
+          flush.call
+        end
+      end
+      flush.call
+      { additions: additions, deletions: deletions }
+    end
+
+    def empty?
+      @additions.zero? && @deletions.zero?
+    end
+
+    def add_tool_result(content)
+      text = content.to_s
+      return false if text.start_with?("Error:", "Declined:")
+
+      add_diff(extract_unified_diff(text))
+    end
+
+    def add_diff(diff)
+      counts = self.class.count(diff)
+      return false if counts[:additions].zero? && counts[:deletions].zero?
+
+      @additions += counts[:additions]
+      @deletions += counts[:deletions]
+      true
+    end
+
+    private
+
+    def self.truncated_diff_stats(diff)
+      match = diff.to_s.match(/^\.\.\. diff truncated to \d+ bytes; full diff stats: \+(\d+)\|-(\d+)\./)
+      return nil unless match
+
+      { additions: match[1].to_i, deletions: match[2].to_i }
+    end
+
+    def self.truncated_diff?(diff)
+      diff.to_s.match?(/^\.\.\. diff truncated to \d+ bytes;/)
+    end
+
+    def self.common_line_count(left, right)
+      previous = Array.new(right.length + 1, 0)
+      left.each do |left_line|
+        current = Array.new(right.length + 1, 0)
+        right.each_with_index do |right_line, index|
+          current[index + 1] = if left_line == right_line
+                                 previous[index] + 1
+                               else
+                                 [current[index], previous[index + 1]].max
+                               end
+        end
+        previous = current
+      end
+      previous.last
+    end
+
+    def self.parse_record(line)
+      JSON.parse(line)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def extract_unified_diff(text)
+      index = text.index(/^--- /)
+      index ? text[index..] : nil
+    end
+  end
+end