kward 0.67.0 → 0.68.0

data/lib/kward/rpc/session_metrics.rb

@@ -0,0 +1,68 @@
+require_relative "../message_access"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # JSON-RPC backend namespace used by UI clients.
+  module RPC
+    # Computes conversation metrics and context usage for RPC runtime payloads.
+    class SessionMetrics
+      def initialize(context_usage:)
+        @context_usage = context_usage
+      end
+
+      def message_count(conversation)
+        conversation.messages.count { |message| MessageAccess.role(message) != "system" }
+      end
+
+      def message_stats(conversation)
+        conversation.messages.each_with_object(default_message_stats) do |message, counts|
+          role = MessageAccess.role(message)
+          next if role == "system"
+
+          counts[:totalMessages] += 1
+          case role
+          when "user"
+            counts[:userMessages] += 1
+          when "assistant"
+            counts[:assistantMessages] += 1
+            counts[:toolCalls] += MessageAccess.tool_calls(message).length
+          when "tool", "toolResult"
+            counts[:toolResults] += 1
+          end
+        end
+      end
+
+      def context_usage(rpc_session, model, client:)
+        context_parts = if client.respond_to?(:current_context_parts)
+                          client.current_context_parts(rpc_session.conversation.messages, rpc_session.tool_registry.schemas)
+                        else
+                          {
+                            provider: model[:provider],
+                            model: model[:id],
+                            messages: rpc_session.conversation.messages,
+                            tools: rpc_session.tool_registry.schemas
+                          }
+                        end
+
+        @context_usage.call(
+          provider: model[:provider],
+          model: model[:id],
+          context_window: model[:contextWindow],
+          context_parts: context_parts
+        )
+      end
+
+      private
+
+      def default_message_stats
+        {
+          userMessages: 0,
+          assistantMessages: 0,
+          toolCalls: 0,
+          toolResults: 0,
+          totalMessages: 0
+        }
+      end
+    end
+  end
+end

data/lib/kward/rpc/session_tree.rb

@@ -0,0 +1,48 @@
+require_relative "../message_access"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # JSON-RPC backend namespace used by UI clients.
+  module RPC
+    # Helper for resolving and selecting persisted session tree entries.
+    class SessionTree
+      def initialize(rpc_session)
+        @rpc_session = rpc_session
+      end
+
+      def entries
+        @rpc_session.store.session_entries(@rpc_session.session.path)
+      end
+
+      def resolve_entry_id(entry_id, entries: self.entries)
+        id = entry_id.to_s
+        return id if entries.any? { |record| record["id"].to_s == id }
+
+        match = id.match(/\Amessage:(\d+)\z/)
+        return entries[match[1].to_i]&.dig("id") if match
+
+        id
+      end
+
+      def active_path_ids(entries, leaf_id)
+        by_id = entries.to_h { |entry| [entry["id"].to_s, entry] }
+        ids = []
+        current = by_id[leaf_id.to_s]
+        while current
+          ids << current["id"].to_s
+          current = by_id[current["parentId"].to_s]
+        end
+        ids
+      end
+
+      def user_entry?(entry)
+        message = entry["message"]
+        message.is_a?(Hash) && MessageAccess.role(message) == "user"
+      end
+
+      def selectable_entry?(entry)
+        !entry["id"].to_s.empty? && ["message", "compaction", "branch_summary"].include?(entry["type"])
+      end
+    end
+  end
+end

data/lib/kward/rpc/session_tree_rows.rb

@@ -0,0 +1,208 @@
+require_relative "../message_access"
+require_relative "../message_text"
+require_relative "../session_tree_tool_display"
+require_relative "../tools/tool_call"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # JSON-RPC backend namespace used by UI clients.
+  module RPC
+    # Builds frontend-neutral RPC row payloads from a persisted session tree.
+    #
+    # `SessionManager` owns session lifecycle and decides when a tree is needed;
+    # this class owns only the mechanics of flattening tree nodes into the row
+    # fields sent over JSON-RPC. Keeping row presentation here prevents the RPC
+    # session coordinator from accumulating rendering details while preserving the
+    # exact Tauren-compatible payload shape.
+    class SessionTreeRows
+      # @param roots [Array<Hash>] tree roots returned by `SessionStore#session_tree`
+      # @param current_leaf [String, nil] active persisted tree leaf id
+      # @param selectable [#call] predicate receiving an entry hash
+      def initialize(roots:, current_leaf:, selectable:)
+        @roots = roots
+        @current_leaf = current_leaf
+        @selectable = selectable
+      end
+
+      # Returns flattened RPC row hashes in active-path-first display order.
+      #
+      # @return [Array<Hash>] rows for the `session/tree` RPC method
+      def rows
+        active_path = tree_active_path(@roots, @current_leaf)
+        tool_calls_by_id = tree_tool_calls(@roots)
+        visible_roots = @roots.flat_map { |root| visible_tree_nodes(root) }
+        multiple_roots = visible_roots.length > 1
+        result = []
+
+        walk = lambda do |node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child|
+          entry = node[:source]["entry"] || {}
+          entry_id = entry["id"].to_s
+          formatted = tree_entry_display(entry, tool_calls_by_id)
+          display_indent = multiple_roots ? [indent - 1, 0].max : indent
+          result << {
+            entryId: entry_id,
+            parentId: entry["parentId"],
+            role: formatted[:role],
+            text: formatted[:text],
+            current: !@current_leaf.to_s.empty? && entry_id == @current_leaf.to_s,
+            depth: display_indent,
+            isLast: is_last,
+            ancestorContinues: gutters.map { |gutter| gutter[:show] },
+            activePath: active_path.include?(entry_id),
+            selectable: @selectable.call(entry),
+            label: node[:source]["label"] || entry["resolvedLabel"],
+            labelTimestamp: node[:source]["labelTimestamp"],
+            prefix: tree_prefix(display_indent, gutters, show_connector && !virtual_root_child, is_last, !node[:children].empty?)
+          }.compact
+
+          children = node[:children].sort_by { |child| tree_contains_active_path?(child, active_path) ? 0 : 1 }
+          multiple_children = children.length > 1
+          child_indent = if multiple_children
+                           indent + 1
+                         elsif just_branched && indent.positive?
+                           indent + 1
+                         else
+                           indent
+                         end
+          connector_position = [display_indent - 1, 0].max
+          child_gutters = show_connector && !virtual_root_child ? gutters + [{ position: connector_position, show: !is_last }] : gutters
+          children.each_with_index do |child, index|
+            walk.call(child, child_indent, multiple_children, multiple_children, index == children.length - 1, child_gutters, false)
+          end
+        end
+
+        visible_roots.sort_by { |root| tree_contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index do |root, index|
+          walk.call(root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == visible_roots.length - 1, [], multiple_roots)
+        end
+        result
+      end
+
+      private
+
+      def tree_active_path(roots, leaf_id)
+        by_id = tree_entries_by_id(roots)
+        ids = []
+        current = by_id[leaf_id.to_s]
+        while current
+          ids << current["id"].to_s
+          current = by_id[current["parentId"].to_s]
+        end
+        ids
+      end
+
+      def tree_entries_by_id(roots)
+        roots.each_with_object({}) do |root, map|
+          stack = [root]
+          until stack.empty?
+            node = stack.pop
+            entry = node["entry"] || {}
+            map[entry["id"].to_s] = entry unless entry["id"].to_s.empty?
+            stack.concat(Array(node["children"]))
+          end
+        end
+      end
+
+      def visible_tree_nodes(node)
+        children = Array(node["children"]).flat_map { |child| visible_tree_nodes(child) }
+        return children if hidden_tree_entry?(node["entry"] || {})
+
+        [{ source: node, children: children }]
+      end
+
+      def hidden_tree_entry?(entry)
+        return false if @current_leaf && entry["id"].to_s == @current_leaf.to_s
+        return false unless entry["type"] == "message"
+
+        message = entry["message"]
+        return false unless message.is_a?(Hash) && MessageAccess.role(message) == "assistant"
+
+        content = MessageAccess.content(message)
+        content_tool_calls = content.is_a?(Array) && content.any? { |part| ToolCall.value(part, :type) == "toolCall" }
+        (content_tool_calls && !tree_text_content?(content)) || (!MessageAccess.tool_calls(message).empty? && MessageText.full_text(message).empty?)
+      end
+
+      def tree_text_content?(content)
+        Array(content).any? { |part| ToolCall.value(part, :type) == "text" && ToolCall.value(part, :text).to_s.strip != "" }
+      end
+
+      def tree_contains_active_path?(node, active_path)
+        entry_id = (node[:source]["entry"] || {})["id"].to_s
+        active_path.include?(entry_id) || node[:children].any? { |child| tree_contains_active_path?(child, active_path) }
+      end
+
+      def tree_tool_calls(roots)
+        roots.each_with_object({}) do |root, tool_calls_by_id|
+          stack = [root]
+          until stack.empty?
+            node = stack.pop
+            entry = node["entry"] || {}
+            message = entry["message"]
+            if entry["type"] == "message" && message.is_a?(Hash) && MessageAccess.role(message) == "assistant"
+              MessageAccess.tool_calls(message).each { |tool_call| tool_calls_by_id[ToolCall.id(tool_call).to_s] = tool_call }
+            end
+            stack.concat(Array(node["children"]))
+          end
+        end
+      end
+
+      def tree_entry_display(entry, tool_calls_by_id = {})
+        case entry["type"]
+        when "message"
+          message = entry["message"] || {}
+          role = MessageAccess.role(message).to_s
+          return { role: "tool", text: format_tool_result(message, tool_calls_by_id) } if ["tool", "toolResult"].include?(role)
+          return { role: role.empty? ? "message" : role, text: display_message_text(message) }
+        when "compaction"
+          return { role: "compaction", text: display_message_text(entry["message"] || {}) }
+        when "branch_summary"
+          return { role: "summary", text: truncate_tree_text(entry["summary"]) }
+        end
+
+        { role: entry["type"].to_s.empty? ? "entry" : entry["type"].to_s, text: entry["type"].to_s }
+      end
+
+      def tree_prefix(display_indent, gutters, show_connector, is_last, foldable)
+        return "" if display_indent.to_i <= 0
+
+        connector_position = show_connector ? display_indent - 1 : -1
+        (0...(display_indent * 3)).map do |index|
+          level = index / 3
+          position = index % 3
+          gutter = gutters.find { |candidate| candidate[:position] == level }
+
+          if gutter
+            position.zero? && gutter[:show] ? "│" : " "
+          elsif show_connector && level == connector_position
+            if position.zero?
+              is_last ? "└" : "├"
+            elsif position == 1
+              foldable ? "⊟" : "─"
+            else
+              " "
+            end
+          else
+            " "
+          end
+        end.join
+      end
+
+      def format_tool_result(message, tool_calls_by_id)
+        tool_call = tool_calls_by_id[MessageAccess.tool_call_id(message).to_s]
+        return SessionTreeToolDisplay.label(tool_call) if tool_call
+
+        name = MessageAccess.tool_name(message).to_s
+        name = "tool" if name.empty?
+        "[#{name}]"
+      end
+
+      def display_message_text(message)
+        truncate_tree_text(MessageText.full_text(message))
+      end
+
+      def truncate_tree_text(text)
+        normalized = text.to_s.gsub(/\s+/, " ").strip
+        normalized.length > 120 ? "#{normalized.slice(0, 117)}..." : normalized
+      end
+    end
+  end
+end

data/lib/kward/rpc/tool_event_normalizer.rb

@@ -1,8 +1,11 @@
 require "time"
 require_relative "tool_metadata"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # JSON-RPC backend namespace used by UI clients.
   module RPC
+    # Converts tool calls and results into RPC event payloads.
     class ToolEventNormalizer
       def initialize(tool_call, content: nil)
         @tool_call = tool_call

data/lib/kward/rpc/tool_metadata.rb

@@ -1,8 +1,11 @@
 require_relative "../tools/tool_call"
 require_relative "../workspace"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # JSON-RPC backend namespace used by UI clients.
   module RPC
+    # Builds compact metadata for RPC tool-call display.
     module ToolMetadata
       module_function
 

data/lib/kward/rpc/transcript_normalizer.rb

@@ -1,8 +1,11 @@
 require_relative "../tools/tool_call"
 require_relative "tool_metadata"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # JSON-RPC backend namespace used by UI clients.
   module RPC
+    # Normalizes Kward transcript messages into Tauren-compatible RPC payloads.
     class TranscriptNormalizer
       IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"].freeze
       THINKING_CONTENT_TYPES = ["thinking", "reasoning"].freeze

data/lib/kward/rpc/transport.rb

@@ -1,7 +1,10 @@
 require "json"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # JSON-RPC backend namespace used by UI clients.
   module RPC
+    # Line-delimited JSON-RPC transport over input and output streams.
     class Transport
       def initialize(input:, output:)
         @input = input

data/lib/kward/session_diff.rb

@@ -1,6 +1,8 @@
 require "json"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Counts unified-diff additions and deletions for summaries.
   class SessionDiff
     attr_reader :additions, :deletions