kward 0.69.0 → 0.70.0

data/lib/kward/prompt_interface.rb

@@ -131,7 +131,7 @@ module Kward
       @banner = Banner.new(message: banner_message, pixels: banner_pixels, screen_height: method(:screen_height))
     end
 
-    def start
+    def start(render: true)
       @mutex.synchronize do
         return if @started
 
@@ -140,7 +140,7 @@ module Kward
         @asking = true
         @output_io.print(KEYBOARD_PROTOCOL_ENABLE)
         @output_io.print(BRACKETED_PASTE_ENABLE)
-        render_prompt_locked
+        render_prompt_locked if render
       end
     end
 
@@ -198,9 +198,10 @@ module Kward
     end
 
     def restore_transcript
+      start(render: false) unless @started
       @mutex.synchronize do
-        clear_prompt_for_output_locked
         @output_io.print(SYNCHRONIZED_OUTPUT_ENABLE)
+        clear_prompt_for_output_locked unless @rendered_rows.zero? && @last_composer_rows.empty?
         @transcript_buffer.clear
         @visual_banner_count = 0
         @transcript_viewport_rows = 0
@@ -213,9 +214,9 @@ module Kward
     ensure
       @mutex.synchronize do
         @restoring_transcript = false
-        @output_io.print(SYNCHRONIZED_OUTPUT_DISABLE)
         width, height = screen_size
         redraw_screen_locked(width: width, height: height)
+        @output_io.print(SYNCHRONIZED_OUTPUT_DISABLE)
         @output_io.flush
       end
     end
@@ -270,6 +271,10 @@ module Kward
       answer.start_with?("y")
     end
 
+    def picker_choice_width
+      [overlay_card_width(screen_width) - 6, 1].max
+    end
+
     def select(message, choices, title: "Sessions", custom: false, initial_index: 0)
       return nil if choices.empty? && !custom
 

data/lib/kward/prompts/commands.rb

@@ -8,10 +8,12 @@ module Kward
       { name: "exit", description: "Exit the interactive session.", argument_hint: "" },
       { name: "quit", description: "Exit the interactive session.", argument_hint: "" },
       { name: "new", description: "Start a new session.", argument_hint: "" },
-      { name: "resume", description: "Resume a saved session.", argument_hint: "[path]" },
+      { name: "sessions", description: "Open the saved sessions picker.", argument_hint: "[path]" },
+      { name: "resume", description: "Alias for /sessions.", argument_hint: "[path]" },
       { name: "name", description: "Name or clear the current session.", argument_hint: "[name]" },
       { name: "clone", description: "Clone the current session.", argument_hint: "" },
-      { name: "tree", description: "Navigate the current session tree.", argument_hint: "" },
+      { name: "rewind", description: "Revisit an earlier prompt and try a different direction.", argument_hint: "" },
+      { name: "tree", description: "Inspect and navigate the full technical session tree.", argument_hint: "" },
       { name: "copy", description: "Copy clean session text to the clipboard.", argument_hint: "[last|transcript]" },
       { name: "export", description: "Export the current session as Markdown.", argument_hint: "[path]" },
       { name: "compact", description: "Compact the current conversation context.", argument_hint: "[instructions]" },

data/lib/kward/rpc/session_manager.rb

@@ -251,8 +251,8 @@ module Kward
         if summarize
           summary = summarize_branch(rpc_session, from_id: previous_leaf, to_id: target_leaf, custom_instructions: custom_instructions)
           target_leaf = rpc_session.session.append_branch_summary(target_leaf, from_id: previous_leaf, summary: summary, details: {})
-        else
-          target_leaf ? rpc_session.session.branch(target_leaf) : rpc_session.session.reset_leaf
+        elsif target_leaf
+          rpc_session.session.branch(target_leaf)
         end
 
         reload_rpc_session(rpc_session)

data/lib/kward/rpc/session_tree_rows.rb

@@ -34,7 +34,12 @@ module Kward
         multiple_roots = visible_roots.length > 1
         result = []
 
-        walk = lambda do |node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child|
+        stack = visible_roots.sort_by { |root| tree_contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
+          [root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == visible_roots.length - 1, [], multiple_roots]
+        end.reverse
+
+        until stack.empty?
+          node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child = stack.pop
           entry = node[:source]["entry"] || {}
           entry_id = entry["id"].to_s
           formatted = tree_entry_display(entry, tool_calls_by_id)
@@ -66,14 +71,10 @@ module Kward
                          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)
+          children.each_with_index.reverse_each do |child, index|
+            stack << [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
 
@@ -83,7 +84,9 @@ module Kward
         by_id = tree_entries_by_id(roots)
         ids = []
         current = by_id[leaf_id.to_s]
-        while current
+        seen = {}
+        while current && !seen[current["id"].to_s]
+          seen[current["id"].to_s] = true
           ids << current["id"].to_s
           current = by_id[current["parentId"].to_s]
         end
@@ -93,8 +96,12 @@ module Kward
       def tree_entries_by_id(roots)
         roots.each_with_object({}) do |root, map|
           stack = [root]
+          seen = {}
           until stack.empty?
             node = stack.pop
+            next if seen[node.object_id]
+
+            seen[node.object_id] = true
             entry = node["entry"] || {}
             map[entry["id"].to_s] = entry unless entry["id"].to_s.empty?
             stack.concat(Array(node["children"]))
@@ -103,10 +110,29 @@ module Kward
       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"] || {})
+        results = {}
+        stack = [[node, false, {}]]
+
+        until stack.empty?
+          current, visited, seen = stack.pop
+          node_key = current.object_id
+          next if seen[node_key]
+
+          if visited
+            children = Array(current["children"]).flat_map { |child| results[child.object_id] || [] }
+            results[node_key] = if hidden_tree_entry?(current["entry"] || {})
+                                  children
+                                else
+                                  [{ source: current, children: children }]
+                                end
+          else
+            branch_seen = seen.merge(node_key => true)
+            stack << [current, true, seen]
+            Array(current["children"]).reverse_each { |child| stack << [child, false, branch_seen] unless branch_seen[child.object_id] }
+          end
+        end
 
-        [{ source: node, children: children }]
+        results[node.object_id] || []
       end
 
       def hidden_tree_entry?(entry)
@@ -126,15 +152,30 @@ module Kward
       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) }
+        stack = [node]
+        seen = {}
+        until stack.empty?
+          current = stack.pop
+          next if seen[current.object_id]
+
+          seen[current.object_id] = true
+          entry_id = (current[:source]["entry"] || {})["id"].to_s
+          return true if active_path.include?(entry_id)
+
+          stack.concat(current[:children])
+        end
+        false
       end
 
       def tree_tool_calls(roots)
         roots.each_with_object({}) do |root, tool_calls_by_id|
           stack = [root]
+          seen = {}
           until stack.empty?
             node = stack.pop
+            next if seen[node.object_id]
+
+            seen[node.object_id] = true
             entry = node["entry"] || {}
             message = entry["message"]
             if entry["type"] == "message" && message.is_a?(Hash) && MessageAccess.role(message) == "assistant"

data/lib/kward/session_diff.rb

@@ -4,11 +4,18 @@ require "json"
 module Kward
   # Counts unified-diff additions and deletions for summaries.
   class SessionDiff
-    attr_reader :additions, :deletions
-
     def initialize(additions: 0, deletions: 0)
-      @additions = additions.to_i
-      @deletions = deletions.to_i
+      @base_additions = additions.to_i
+      @base_deletions = deletions.to_i
+      @file_changes = Hash.new { |changes, path| changes[path] = { removed: [], added: [] } }
+    end
+
+    def additions
+      @base_additions + @file_changes.values.sum { |changes| changes[:added].length }
+    end
+
+    def deletions
+      @base_deletions + @file_changes.values.sum { |changes| changes[:removed].length }
     end
 
     def self.from_session_file(path)
@@ -65,7 +72,7 @@ module Kward
     end
 
     def empty?
-      @additions.zero? && @deletions.zero?
+      additions.zero? && deletions.zero?
     end
 
     def add_tool_result(content)
@@ -76,11 +83,19 @@ module Kward
     end
 
     def add_diff(diff)
-      counts = self.class.count(diff)
-      return false if counts[:additions].zero? && counts[:deletions].zero?
+      if self.class.truncated_diff_stats(diff) || self.class.truncated_diff?(diff)
+        counts = self.class.count(diff)
+        return false if counts[:additions].zero? && counts[:deletions].zero?
 
-      @additions += counts[:additions]
-      @deletions += counts[:deletions]
+        @base_additions += counts[:additions]
+        @base_deletions += counts[:deletions]
+        return true
+      end
+
+      changes = self.class.changed_lines_by_file(diff)
+      return false if changes.empty?
+
+      changes.each { |path, lines| apply_file_change(path, lines) }
       true
     end
 
@@ -113,12 +128,94 @@ module Kward
       previous.last
     end
 
+    def self.changed_lines_by_file(diff)
+      current_path = nil
+      changes = Hash.new { |file_changes, path| file_changes[path] = { removed: [], added: [] } }
+      removed = []
+      added = []
+      flush = lambda do
+        unmatched = unmatched_lines(removed, added)
+        changes[current_path][:removed].concat(unmatched[:removed]) if current_path
+        changes[current_path][:added].concat(unmatched[:added]) if current_path
+        removed.clear
+        added.clear
+      end
+
+      diff.to_s.each_line do |line|
+        if line.start_with?("--- ")
+          flush.call
+          current_path = line[4..].to_s.chomp
+        elsif 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
+      changes.reject { |_path, lines| lines[:removed].empty? && lines[:added].empty? }
+    end
+
+    def self.unmatched_lines(left, right)
+      matches = common_line_indexes(left, right)
+      left_matches = matches.map(&:first)
+      right_matches = matches.map(&:last)
+      {
+        removed: left.each_index.reject { |index| left_matches.include?(index) }.map { |index| left[index] },
+        added: right.each_index.reject { |index| right_matches.include?(index) }.map { |index| right[index] }
+      }
+    end
+
+    def self.common_line_indexes(left, right)
+      lengths = Array.new(left.length + 1) { Array.new(right.length + 1, 0) }
+      left.each_with_index do |left_line, left_index|
+        right.each_with_index do |right_line, right_index|
+          lengths[left_index + 1][right_index + 1] = if left_line == right_line
+                                                        lengths[left_index][right_index] + 1
+                                                      else
+                                                        [lengths[left_index + 1][right_index], lengths[left_index][right_index + 1]].max
+                                                      end
+        end
+      end
+
+      indexes = []
+      left_index = left.length
+      right_index = right.length
+      while left_index.positive? && right_index.positive?
+        if left[left_index - 1] == right[right_index - 1]
+          indexes.unshift([left_index - 1, right_index - 1])
+          left_index -= 1
+          right_index -= 1
+        elsif lengths[left_index - 1][right_index] >= lengths[left_index][right_index - 1]
+          left_index -= 1
+        else
+          right_index -= 1
+        end
+      end
+      indexes
+    end
+
     def self.parse_record(line)
       JSON.parse(line)
     rescue JSON::ParserError
       nil
     end
 
+    def apply_file_change(path, lines)
+      remove_reverted_lines(@file_changes[path][:added], lines[:removed])
+      remove_reverted_lines(@file_changes[path][:removed], lines[:added])
+      @file_changes[path][:removed].concat(lines[:removed])
+      @file_changes[path][:added].concat(lines[:added])
+    end
+
+    def remove_reverted_lines(previous_lines, current_lines)
+      current_lines.delete_if do |line|
+        index = previous_lines.index(line)
+        previous_lines.delete_at(index) if index
+      end
+    end
+
     def extract_unified_diff(text)
       index = text.index(/^--- /)
       index ? text[index..] : nil

data/lib/kward/session_store.rb

@@ -592,7 +592,11 @@ module Kward
         next unless node
 
         parent = nodes[entry["parentId"].to_s]
-        parent ? parent["children"] << node : roots << node
+        if parent && !parent.equal?(node)
+          parent["children"] << node unless parent["children"].include?(node)
+        else
+          roots << node unless roots.include?(node)
+        end
       end
       roots
     end

data/lib/kward/session_tree_renderer.rb

@@ -19,7 +19,12 @@ module Kward
       multiple_roots = visible_roots.length > 1
       result = []
 
-      walk = lambda do |node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child|
+      stack = visible_roots.sort_by { |root| session_tree_contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
+        [root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == visible_roots.length - 1, [], multiple_roots]
+      end.reverse
+
+      until stack.empty?
+        node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child = stack.pop
         entry = node[:source]["entry"] || {}
         display_indent = multiple_roots ? [indent - 1, 0].max : indent
         prefix = session_tree_visual_prefix(display_indent, gutters, show_connector && !virtual_root_child, is_last, !node[:children].empty?)
@@ -40,25 +45,40 @@ module Kward
         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)
+        children.each_with_index.reverse_each do |child, index|
+          stack << [child, child_indent, multiple_children, multiple_children, index == children.length - 1, child_gutters, false]
         end
       end
 
-      visible_roots.sort_by { |root| session_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 visible_session_tree_nodes(node)
-      children = Array(node["children"]).flat_map { |child| visible_session_tree_nodes(child) }
-      return children if hidden_session_tree_entry?(node["entry"] || {})
+      results = {}
+      stack = [[node, false, {}]]
+
+      until stack.empty?
+        current, visited, seen = stack.pop
+        node_key = current.object_id
+        next if seen[node_key]
+
+        if visited
+          children = Array(current["children"]).flat_map { |child| results[child.object_id] || [] }
+          results[node_key] = if hidden_session_tree_entry?(current["entry"] || {})
+                                children
+                              else
+                                [{ source: current, children: children }]
+                              end
+        else
+          branch_seen = seen.merge(node_key => true)
+          stack << [current, true, seen]
+          Array(current["children"]).reverse_each { |child| stack << [child, false, branch_seen] unless branch_seen[child.object_id] }
+        end
+      end
 
-      [{ source: node, children: children }]
+      results[node.object_id] || []
     end
 
     def hidden_session_tree_entry?(entry)
@@ -110,7 +130,8 @@ module Kward
       return "" if display_indent.to_i <= 0
 
       connector_position = show_connector ? display_indent - 1 : -1
-      (0...(display_indent * 3)).map do |index|
+      indentation = "      "
+      indentation + (0...(display_indent * 3)).map do |index|
         level = index / 3
         position = index % 3
         gutter = gutters.find { |candidate| candidate[:position] == level }
@@ -132,15 +153,28 @@ module Kward
     end
 
     def session_tree_contains_active_path?(node, active_path)
-      entry_id = (node[:source]["entry"] || {})["id"].to_s
-      active_path.include?(entry_id) || node[:children].any? { |child| session_tree_contains_active_path?(child, active_path) }
+      stack = [node]
+      seen = {}
+      until stack.empty?
+        current = stack.pop
+        next if seen[current.object_id]
+
+        seen[current.object_id] = true
+        entry_id = (current[:source]["entry"] || {})["id"].to_s
+        return true if active_path.include?(entry_id)
+
+        stack.concat(current[:children])
+      end
+      false
     end
 
     def session_tree_active_path(roots, leaf_id)
       by_id = session_tree_entries_by_id(roots)
       ids = []
       entry = by_id[leaf_id.to_s]
-      while entry
+      seen = {}
+      while entry && !seen[entry["id"].to_s]
+        seen[entry["id"].to_s] = true
         ids << entry["id"].to_s
         entry = by_id[entry["parentId"].to_s]
       end
@@ -150,8 +184,12 @@ module Kward
     def session_tree_entries_by_id(roots)
       roots.each_with_object({}) do |root, map|
         stack = [root]
+        seen = {}
         until stack.empty?
           node = stack.pop
+          next if seen[node.object_id]
+
+          seen[node.object_id] = true
           entry = node["entry"] || {}
           map[entry["id"].to_s] = entry unless entry["id"].to_s.empty?
           stack.concat(Array(node["children"]))
@@ -162,8 +200,12 @@ module Kward
     def session_tree_tool_calls(roots)
       roots.each_with_object({}) do |root, tool_calls|
         stack = [root]
+        seen = {}
         until stack.empty?
           node = stack.pop
+          next if seen[node.object_id]
+
+          seen[node.object_id] = true
           entry = node["entry"] || {}
           message = entry["message"]
           if entry["type"] == "message" && message.is_a?(Hash) && message_role(message) == "assistant"

data/lib/kward/version.rb

@@ -1,5 +1,5 @@
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Current gem version.
-  VERSION = "0.69.0"
+  VERSION = "0.70.0"
 end