kward 0.66.0 → 0.67.0

data/lib/kward/rpc/tool_event_normalizer.rb

@@ -10,19 +10,16 @@ module Kward
         @fields = ToolMetadata.normalized_tool_fields(@tool_call)
       end
 
-      def call_payload(legacy_tool: nil)
+      def call_payload
         {
-          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(
+      def result_payload
+        call_payload.merge(
           content: @content,
           result: normalized_result
         )
@@ -48,8 +45,10 @@ module Kward
         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
+          if mutation_tool?
+            diff = ToolMetadata.extract_unified_diff(text)
+            result[:diff] = diff if diff
+          end
 
           files = changed_files
           result[:changedFiles] = files if files.any?
@@ -58,11 +57,15 @@ module Kward
       end
 
       def changed_files
-        return [] unless ["edit", "write"].include?(@fields[:toolName])
+        return [] unless mutation_tool?
 
         path = @fields.dig(:args, :path)
         path.to_s.empty? ? [] : [path]
       end
+
+      def mutation_tool?
+        ["edit", "write"].include?(@fields[:toolName])
+      end
     end
   end
 end

data/lib/kward/rpc/transcript_normalizer.rb

@@ -21,7 +21,7 @@ module Kward
       def normalize_message(message)
         return nil unless message.is_a?(Hash)
 
-        case value(message, :role).to_s
+        case ToolCall.value(message, :role).to_s
         when "system"
           nil
         when "user"
@@ -42,9 +42,9 @@ module Kward
       end
 
       def normalize_compaction_summary(message)
-        summary = value(message, :summary) || value(message, :content)
+        summary = ToolCall.value(message, :summary) || ToolCall.value(message, :content)
         result = { role: "compactionSummary", summary: summary.to_s }
-        tokens_before = value(message, :tokensBefore) || value(message, :tokens_before)
+        tokens_before = ToolCall.value(message, :tokensBefore) || ToolCall.value(message, :tokens_before)
         result[:tokensBefore] = tokens_before if tokens_before
         result
       end
@@ -52,12 +52,12 @@ module Kward
       def normalize_user_message(message)
         {
           role: "user",
-          content: normalize_content(value(message, :content))
+          content: normalize_content(ToolCall.value(message, :content))
         }
       end
 
       def normalize_assistant_message(message)
-        content = reasoning_first_content(normalize_content(value(message, :content), preserve_thinking: true))
+        content = reasoning_first_content(normalize_content(ToolCall.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|
@@ -69,17 +69,17 @@ module Kward
         end
 
         result = { role: "assistant", content: content }
-        error_message = value(message, :errorMessage) || value(message, :error_message)
+        error_message = ToolCall.value(message, :errorMessage) || ToolCall.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)
+        tool_call_id = ToolCall.value(message, :toolCallId) || ToolCall.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)
+        raw_name = ToolCall.value(message, :toolName) || ToolCall.value(message, :tool_name) || ToolCall.value(message, :name)
         tool_name = normalize_tool_name(raw_name) || raw_name || matching_call&.dig(:name)
-        content = normalize_content(value(message, :content))
+        content = normalize_content(ToolCall.value(message, :content))
 
         result = {
           role: "toolResult",
@@ -120,10 +120,10 @@ module Kward
       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
+        type = ToolCall.value(part, :type).to_s
         case type
         when "text"
-          text = value(part, :text)
+          text = ToolCall.value(part, :text)
           text.nil? ? nil : { type: "text", text: text.to_s }
         when "image"
           normalize_image_part(part)
@@ -137,17 +137,17 @@ module Kward
       end
 
       def normalize_unknown_content_part(part)
-        text = value(part, :text)
+        text = ToolCall.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 = ToolCall.value(part, :thinking) || ToolCall.value(part, :reasoning) || ToolCall.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 = ToolCall.value(message, :reasoning_summary) || ToolCall.value(message, :reasoningSummary)
         summary.to_s.empty? ? nil : { type: "thinking", thinking: summary.to_s }
       end
 
@@ -161,36 +161,36 @@ module Kward
       end
 
       def thinking_content_part?(part)
-        part.is_a?(Hash) && value(part, :type) == "thinking"
+        part.is_a?(Hash) && ToolCall.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 = ToolCall.value(part, :mimeType) || ToolCall.value(part, :mime_type) || ToolCall.value(part, :media_type)
         mime_type = normalize_mime_type(mime_type)
         return nil unless IMAGE_MIME_TYPES.include?(mime_type)
 
-        data = value(part, :data)
+        data = ToolCall.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))
+        alt = ToolCall.value(part, :alt) || image_alt_from_path(ToolCall.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) || {}
+        raw_name = ToolCall.value(part, :name)
+        arguments = ToolCall.value(part, :arguments) || {}
         {
           type: "toolCall",
-          id: value(part, :id),
+          id: ToolCall.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)
+        explicit_details = ToolCall.value(message, :details)
         details = explicit_details.is_a?(Hash) ? safe_details(explicit_details) : {}
         text = content_text(content)
 
@@ -205,9 +205,9 @@ module Kward
 
       def safe_details(details)
         allowed = {}
-        diff = value(details, :diff)
+        diff = ToolCall.value(details, :diff)
         allowed[:diff] = diff if diff
-        changed_files = value(details, :changedFiles) || value(details, :changed_files)
+        changed_files = ToolCall.value(details, :changedFiles) || ToolCall.value(details, :changed_files)
         allowed[:changedFiles] = changed_files if changed_files.is_a?(Array)
         allowed
       end
@@ -228,8 +228,8 @@ module Kward
       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)
+        return ToolCall.value(message, :isError) if has_key?(message, :isError)
+        return ToolCall.value(message, :is_error) if has_key?(message, :is_error)
 
         ToolMetadata.error_result?(content_text(content))
       end
@@ -241,7 +241,7 @@ module Kward
       end
 
       def tool_calls(message)
-        calls = value(message, :tool_calls) || value(message, :toolCalls)
+        calls = ToolCall.value(message, :tool_calls) || ToolCall.value(message, :toolCalls)
         calls.is_a?(Array) ? calls : []
       end
 
@@ -253,40 +253,22 @@ module Kward
         args = ToolCall.parse_arguments(arguments)
         case name.to_s
         when "edit_file", "edit"
-          normalize_edit_args(args)
+          ToolMetadata.normalize_tool_args(name, args)
         when "run_shell_command", "bash"
           normalize_bash_args(args)
         else
-          camelize_tool_args(args)
+          ToolCall.camelize_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 = ToolCall.camelize_args(args)
+        timeout = ToolCall.value(args, :timeoutSeconds) || ToolCall.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
@@ -295,10 +277,6 @@ module Kward
         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

data/lib/kward/session_store.rb

@@ -5,21 +5,23 @@ require "time"
 require_relative "config_files"
 require_relative "conversation"
 require_relative "message_access"
+require_relative "private_file"
 require_relative "rpc/tool_event_normalizer"
 require_relative "tools/tool_call"
 require_relative "workspace"
 
 module Kward
   class SessionStore
-    VERSION = 1
+    VERSION = 2
+    LAST_SESSION_FILENAME = "last_session.json"
 
     SessionInfo = Struct.new(:id, :path, :cwd, :created_at, :modified_at, :name, :first_message, :message_count, :parent_id, :parent_path, :depth, :is_last, :ancestor_continues, keyword_init: true)
 
     class Session
       attr_reader :id, :path, :cwd, :created_at, :parent_id, :parent_path
-      attr_accessor :name
+      attr_accessor :name, :leaf_id
 
-      def initialize(store:, id:, path:, cwd:, created_at:, name: nil, parent_id: nil, parent_path: nil)
+      def initialize(store:, id:, path:, cwd:, created_at:, name: nil, parent_id: nil, parent_path: nil, leaf_id: nil)
         @store = store
         @id = id
         @path = path
@@ -28,6 +30,7 @@ module Kward
         @name = name
         @parent_id = parent_id
         @parent_path = parent_path
+        @leaf_id = leaf_id
       end
 
       def attach(conversation)
@@ -38,19 +41,15 @@ module Kward
       end
 
       def append_message(message)
-        @store.append_record(@path, {
-          type: "message",
-          timestamp: Time.now.utc.iso8601(3),
-          message: message
-        })
+        record = @store.build_tree_record(@path, "message", @leaf_id, message: message)
+        @leaf_id = record[:id]
+        @store.append_record(@path, record)
       end
 
       def compact(message)
-        @store.append_record(@path, {
-          type: "compaction",
-          timestamp: Time.now.utc.iso8601(3),
-          message: message
-        })
+        record = @store.build_tree_record(@path, "compaction", @leaf_id, message: message)
+        @leaf_id = record[:id]
+        @store.append_record(@path, record)
       end
 
       def append_tool_execution(tool_call, content)
@@ -75,6 +74,26 @@ module Kward
         })
       end
 
+      def branch(entry_id)
+        @leaf_id = entry_id.to_s.empty? ? nil : entry_id.to_s
+        @store.append_leaf_change(@path, @leaf_id)
+      end
+
+      def reset_leaf
+        branch(nil)
+      end
+
+      def append_label_change(entry_id, label)
+        @store.append_label_change(@path, entry_id, label)
+      end
+
+      def append_branch_summary(parent_id, from_id:, summary:, details: {})
+        record = @store.build_tree_record(@path, "branch_summary", parent_id, fromId: from_id, summary: summary, details: details || {})
+        @leaf_id = record[:id]
+        @store.append_record(@path, record)
+        record[:id]
+      end
+
       def update_runtime(model:, reasoning_effort:)
         @store.append_record(@path, {
           type: "session_info",
@@ -121,11 +140,12 @@ module Kward
       end
       File.chmod(0o600, path)
 
-      Session.new(store: self, id: id, path: path, cwd: @cwd, created_at: created_at, parent_id: parent_id, parent_path: parent_path)
+      Session.new(store: self, id: id, path: path, cwd: @cwd, created_at: created_at, parent_id: parent_id, parent_path: parent_path, leaf_id: nil)
     end
 
     def create_from_conversation(conversation, parent_session: nil)
       session = create(model: conversation.model, reasoning_effort: conversation.reasoning_effort, parent_id: parent_session&.id, parent_path: parent_session&.path)
+      session.rename(parent_session.name) unless parent_session&.name.to_s.strip.empty?
       persisted_messages(conversation).each { |message| session.append_message(message) }
       session.attach(conversation)
       session
@@ -143,6 +163,7 @@ module Kward
 
     def create_independent_from_messages(messages, read_paths: [], model: nil, reasoning_effort: nil, parent_session: nil)
       session = create(model: model, reasoning_effort: reasoning_effort, parent_id: parent_session&.id, parent_path: parent_session&.path)
+      session.rename(parent_session.name) unless parent_session&.name.to_s.strip.empty?
       persisted = deep_copy(messages)
       persisted.each { |message| session.append_message(message) }
       conversation = Conversation.new(messages: deep_copy(persisted), read_paths: read_paths, workspace_root: @cwd, model: model, reasoning_effort: reasoning_effort)
@@ -162,6 +183,7 @@ module Kward
       records = records_from_file(resolved_path)
       header = session_header(records, resolved_path)
 
+      leaf_id = current_leaf_id(records)
       messages = restored_messages(records)
       name = session_name(records)
       read_paths = restored_read_paths(messages, workspace)
@@ -186,18 +208,42 @@ module Kward
         created_at: parse_time(header["timestamp"]) || File.mtime(resolved_path),
         name: name,
         parent_id: header["parentId"],
-        parent_path: header["parentPath"]
+        parent_path: header["parentPath"],
+        leaf_id: leaf_id
       )
       session.attach(conversation)
       [session, conversation]
     end
 
     def recent(limit: 20)
-      recent_sessions.first(limit)
+      limit ? recent_sessions.first(limit) : recent_sessions
+    end
+
+    def remember_last_session(session)
+      return unless session&.path
+
+      FileUtils.mkdir_p(session_dir, mode: 0o700)
+      PrivateFile.write_json(last_session_path, { "path" => File.expand_path(session.path), "timestamp" => Time.now.utc.iso8601(3) })
+    end
+
+    def last_session_path
+      File.join(session_dir, LAST_SESSION_FILENAME)
+    end
+
+    def remembered_last_session_path
+      return nil unless File.file?(last_session_path)
+
+      path = JSON.parse(File.read(last_session_path))["path"].to_s
+      return nil if path.empty? || !File.file?(path)
+
+      path
+    rescue JSON::ParserError
+      nil
     end
 
     def recent_tree(limit: 20)
-      decorate_tree(recent_sessions.first(limit))
+      sessions = limit ? recent_sessions.first(limit) : recent_sessions
+      decorate_tree(sessions)
     end
 
     def delete_unused_session(session)
@@ -215,6 +261,63 @@ module Kward
       File.join(@config_dir, "sessions", self.class.safe_cwd(@cwd))
     end
 
+
+    def build_tree_record(path, type, parent_id, fields = {})
+      message = fields[:message]
+      id = message_entry_id(message) || next_entry_id(path)
+      assign_message_entry_id(message, id) if message.is_a?(Hash)
+      {
+        type: type,
+        id: id,
+        parentId: parent_id,
+        timestamp: Time.now.utc.iso8601(3)
+      }.merge(fields).delete_if { |_key, value| value.nil? }
+    end
+
+    def append_leaf_change(path, leaf_id)
+      append_record(path, {
+        type: "leaf",
+        timestamp: Time.now.utc.iso8601(3),
+        targetId: leaf_id
+      })
+    end
+
+    def append_label_change(path, entry_id, label)
+      append_record(path, {
+        type: "label",
+        id: next_entry_id(path),
+        timestamp: Time.now.utc.iso8601(3),
+        targetId: entry_id.to_s,
+        label: label.to_s.strip.empty? ? nil : label.to_s.strip
+      })
+    end
+
+    def session_tree(path)
+      records = records_from_file(resolve_session_path(path))
+      build_session_tree(records)
+    end
+
+    def session_entries(path)
+      records = records_from_file(resolve_session_path(path))
+      labels = labels_by_target(records)
+      timestamps = label_timestamps_by_target(records)
+      records.select { |record| tree_entry_record?(record) }.map do |record|
+        id = record["id"].to_s
+        record.dup.tap do |copy|
+          copy["resolvedLabel"] = labels[id] if labels.key?(id)
+          copy["labelTimestamp"] = timestamps[id] if timestamps.key?(id)
+        end
+      end
+    end
+
+    def session_entry(path, entry_id)
+      session_entries(path).find { |record| record["id"].to_s == entry_id.to_s }
+    end
+
+    def current_leaf(path)
+      current_leaf_id(records_from_file(resolve_session_path(path)))
+    end
+
     def append_record(path, record)
       File.open(path, "a", 0o600) do |file|
         file.write(JSON.generate(record))
@@ -237,11 +340,27 @@ module Kward
     end
 
     def records_from_file(path)
-      File.readlines(path, chomp: true).filter_map do |line|
+      records = File.readlines(path, chomp: true).filter_map do |line|
         JSON.parse(line)
       rescue JSON::ParserError
         nil
       end
+      normalize_tree_records(records)
+    end
+
+    def normalize_tree_records(records)
+      parent_id = nil
+      entry_index = 0
+      records.each do |record|
+        next unless tree_entry_record?(record)
+
+        record["id"] = "message:#{entry_index}" if record["id"].to_s.empty?
+        record["parentId"] = parent_id unless record.key?("parentId")
+        assign_message_entry_id(record["message"], record["id"]) if record["message"].is_a?(Hash) && message_entry_id(record["message"]).to_s.empty?
+        parent_id = record["id"]
+        entry_index += 1
+      end
+      records
     end
 
     def session_header(records, path)
@@ -306,17 +425,127 @@ module Kward
     end
 
     def restored_messages(records)
-      records.each_with_object([]) do |record, messages|
+      branch_records(records).each_with_object([]) do |record, messages|
         message = record["message"]
         case record["type"]
         when "message"
           messages << message if message.is_a?(Hash)
         when "compaction"
           messages.replace(rebuilt_compacted_messages(message, messages)) if message.is_a?(Hash)
+        when "branch_summary"
+          messages << { "role" => "branchSummary", "content" => record["summary"].to_s, "id" => record["id"] }
+        end
+      end
+    end
+
+
+    def build_session_tree(records)
+      entries = records.select { |record| tree_entry_record?(record) }
+      labels = labels_by_target(records)
+      label_timestamps = label_timestamps_by_target(records)
+      nodes = entries.each_with_object({}) do |entry, map|
+        id = entry["id"].to_s
+        next if id.empty?
+
+        node = { "entry" => decorate_tree_entry(entry), "children" => [] }
+        node["label"] = labels[id] if labels.key?(id)
+        node["labelTimestamp"] = label_timestamps[id] if label_timestamps.key?(id)
+        map[id] = node
+      end
+      roots = []
+      entries.each do |entry|
+        id = entry["id"].to_s
+        node = nodes[id]
+        next unless node
+
+        parent = nodes[entry["parentId"].to_s]
+        parent ? parent["children"] << node : roots << node
+      end
+      roots
+    end
+
+    def decorate_tree_entry(entry)
+      entry.dup
+    end
+
+    def branch_records(records)
+      return legacy_branch_records(records) unless records.any? { |record| tree_entry_record?(record) && !record["id"].to_s.empty? }
+
+      entries = records.select { |record| tree_entry_record?(record) }
+      by_id = entries.to_h { |record| [record["id"].to_s, record] }
+      leaf_id = current_leaf_id(records)
+      return [] if leaf_id.nil?
+
+      branch = []
+      seen = {}
+      current = by_id[leaf_id.to_s]
+      while current && !seen[current["id"].to_s]
+        seen[current["id"].to_s] = true
+        branch << current
+        parent_id = current["parentId"]
+        current = parent_id ? by_id[parent_id.to_s] : nil
+      end
+      branch.reverse
+    end
+
+    def legacy_branch_records(records)
+      records.select { |record| ["message", "compaction"].include?(record["type"]) }
+    end
+
+    def current_leaf_id(records)
+      latest = records.reverse.find { |record| record["type"] == "leaf" || (tree_entry_record?(record) && !record["id"].to_s.empty?) }
+      return nil unless latest
+      return latest["targetId"] if latest["type"] == "leaf"
+
+      latest["id"]
+    end
+
+    def tree_entry_record?(record)
+      ["message", "compaction", "branch_summary"].include?(record["type"])
+    end
+
+    def labels_by_target(records)
+      records.each_with_object({}) do |record, labels|
+        next unless record["type"] == "label"
+
+        target = record["targetId"].to_s
+        next if target.empty?
+
+        label = record["label"].to_s.strip
+        label.empty? ? labels.delete(target) : labels[target] = label
+      end
+    end
+
+    def label_timestamps_by_target(records)
+      records.each_with_object({}) do |record, timestamps|
+        next unless record["type"] == "label"
+
+        target = record["targetId"].to_s
+        next if target.empty?
+
+        if record["label"].to_s.strip.empty?
+          timestamps.delete(target)
+        else
+          timestamps[target] = record["timestamp"]
         end
       end
     end
 
+    def next_entry_id(_path)
+      SecureRandom.hex(4)
+    end
+
+    def message_entry_id(message)
+      return nil unless message.respond_to?(:key?)
+
+      message["id"] || message[:id]
+    end
+
+    def assign_message_entry_id(message, id)
+      message["id"] = id
+      message.delete(:id) if message.key?(:id)
+    end
+
     def rebuilt_compacted_messages(compaction_message, previous_messages)
       first_kept_entry_id = compaction_message["first_kept_entry_id"] || compaction_message["firstKeptEntryId"]
       return [compaction_message] if first_kept_entry_id.to_s.empty?
@@ -347,10 +576,23 @@ module Kward
 
     def recent_sessions
       Dir.glob(File.join(session_dir, "*.jsonl")).filter_map do |path|
-        session_info(path)
+        info = session_info(path)
+        next unless info
+        next if delete_empty_unnamed_session_info(info)
+
+        info
       end.sort_by { |info| info.modified_at || Time.at(0) }.reverse
     end
 
+    def delete_empty_unnamed_session_info(info)
+      return false unless info.name.to_s.strip.empty? && info.message_count.to_i.zero?
+
+      File.delete(info.path)
+      true
+    rescue StandardError
+      false
+    end
+
     def decorate_tree(sessions)
       by_parent = Hash.new { |hash, key| hash[key] = [] }
       ids = sessions.map(&:id).to_h { |id| [id, true] }