kward 0.71.0 → 0.72.0

data/lib/kward/session_tree_renderer.rb

@@ -1,7 +1,7 @@
 require_relative "message_access"
 require_relative "message_text"
+require_relative "session_tree_nodes"
 require_relative "session_tree_tool_display"
-require_relative "tools/tool_call"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -13,13 +13,14 @@ module Kward
     end
 
     def items
-      active_path = session_tree_active_path(@roots, @current_leaf_id)
-      tool_calls_by_id = session_tree_tool_calls(@roots)
-      visible_roots = @roots.flat_map { |root| visible_session_tree_nodes(root) }
+      tree_nodes = SessionTreeNodes.new(roots: @roots, current_leaf: @current_leaf_id)
+      active_path = tree_nodes.active_path
+      tool_calls_by_id = tree_nodes.tool_calls
+      visible_roots = tree_nodes.visible_roots
       multiple_roots = visible_roots.length > 1
       result = []
 
-      stack = visible_roots.sort_by { |root| session_tree_contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
+      stack = visible_roots.sort_by { |root| tree_nodes.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
 
@@ -33,7 +34,7 @@ module Kward
           label: session_tree_label(entry, node[:source], prefix, active_path.include?(entry["id"].to_s), tool_calls_by_id)
         }
 
-        children = node[:children].sort_by { |child| session_tree_contains_active_path?(child, active_path) ? 0 : 1 }
+        children = node[:children].sort_by { |child| tree_nodes.contains_active_path?(child, active_path) ? 0 : 1 }
         multiple_children = children.length > 1
         child_indent = if multiple_children
                          indent + 1
@@ -55,52 +56,6 @@ module Kward
 
     private
 
-    def visible_session_tree_nodes(node)
-      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
-
-      results[node.object_id] || []
-    end
-
-    def hidden_session_tree_entry?(entry)
-      return false if @current_leaf_id && entry["id"].to_s == @current_leaf_id.to_s
-      return false unless entry["type"] == "message"
-
-      message = entry["message"]
-      return false unless message.is_a?(Hash) && message_role(message) == "assistant"
-
-      content = message_content(message)
-      content_tool_calls = content.is_a?(Array) && content.any? { |part| session_tree_content_part_value(part, :type) == "toolCall" }
-      (content_tool_calls && !session_tree_text_content?(content)) || (!message_tool_calls(message).empty? && full_message_text(message).empty?)
-    end
-
-    def session_tree_text_content?(content)
-      Array(content).any? { |part| session_tree_content_part_value(part, :type) == "text" && session_tree_content_part_value(part, :text).to_s.strip != "" }
-    end
-
-    def session_tree_content_part_value(part, key)
-      MessageAccess.value(part, key)
-    end
-
     def session_tree_label(entry, node, prefix, active_path, tool_calls_by_id)
       label = node["label"] || entry["resolvedLabel"]
       label = label.to_s.strip
@@ -152,70 +107,6 @@ module Kward
       end.join
     end
 
-    def session_tree_contains_active_path?(node, 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]
-      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
-      ids
-    end
-
-    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"]))
-        end
-      end
-    end
-
-    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"
-            message_tool_calls(message).each { |tool_call| tool_calls[tool_call_id(tool_call).to_s] = tool_call }
-          end
-          stack.concat(Array(node["children"]))
-        end
-      end
-    end
-
     def session_tree_tool_display(message, tool_calls_by_id)
       tool_call = tool_calls_by_id[session_tree_message_tool_call_id(message).to_s]
       return SessionTreeToolDisplay.label(tool_call) if tool_call
@@ -233,12 +124,11 @@ module Kward
     end
 
     def display_message_text(message)
-      truncate_session_tree_text(full_message_text(message))
+      SessionTreeNodes.truncate_text(full_message_text(message))
     end
 
     def truncate_session_tree_text(text)
-      normalized = text.to_s.gsub(/\s+/, " ").strip
-      normalized.length > 120 ? "#{normalized.slice(0, 117)}..." : normalized
+      SessionTreeNodes.truncate_text(text)
     end
 
     def full_message_text(message)
@@ -249,10 +139,6 @@ module Kward
       MessageAccess.role(message)
     end
 
-    def message_content(message)
-      MessageAccess.content(message)
-    end
-
     def message_name(message)
       MessageAccess.name(message)
     end
@@ -261,13 +147,5 @@ module Kward
       MessageAccess.tool_call_id(message)
     end
 
-    def message_tool_calls(message)
-      MessageAccess.tool_calls(message)
-    end
-
-    def tool_call_id(tool_call)
-      ToolCall.id(tool_call)
-    end
-
   end
 end

data/lib/kward/tab_store.rb

@@ -0,0 +1,47 @@
+require "digest"
+require "json"
+require_relative "config_files"
+require_relative "private_file"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Persists the terminal UI's open session tabs per workspace.
+  class TabStore
+    def initialize(config_dir: ConfigFiles.config_dir, cwd: Dir.pwd)
+      @config_dir = config_dir
+      @cwd = File.expand_path(cwd)
+    end
+
+    def load
+      return { "session_paths" => [], "active_index" => 0 } unless File.file?(path)
+
+      data = JSON.parse(File.read(path))
+      paths = Array(data["session_paths"]).map(&:to_s).reject(&:empty?)
+      labels = Array(data["labels"]).map(&:to_s)
+      active_index = data["active_index"].to_i
+      { "session_paths" => paths, "labels" => labels, "active_index" => active_index }
+    rescue JSON::ParserError
+      { "session_paths" => [], "active_index" => 0 }
+    end
+
+    def save(session_paths:, active_index:, labels: [])
+      paths = Array(session_paths).map(&:to_s).reject(&:empty?)
+      PrivateFile.write_json(path, {
+        "cwd" => @cwd,
+        "session_paths" => paths,
+        "labels" => Array(labels).map(&:to_s),
+        "active_index" => [[active_index.to_i, 0].max, [paths.length - 1, 0].max].min
+      })
+    end
+
+    def path
+      File.join(@config_dir, "tabs", "#{workspace_key}.json")
+    end
+
+    private
+
+    def workspace_key
+      Digest::SHA256.hexdigest(@cwd)[0, 24]
+    end
+  end
+end

data/lib/kward/text_boundary.rb

@@ -0,0 +1,25 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Small text navigation helpers shared by composer and editor buffers.
+  module TextBoundary
+    module_function
+
+    def previous_word_boundary(text, index)
+      cursor = index.to_i
+      cursor -= 1 while cursor.positive? && word_separator?(text[cursor - 1])
+      cursor -= 1 while cursor.positive? && !word_separator?(text[cursor - 1])
+      cursor
+    end
+
+    def next_word_boundary(text, index)
+      cursor = index.to_i
+      cursor += 1 while cursor < text.length && word_separator?(text[cursor])
+      cursor += 1 while cursor < text.length && !word_separator?(text[cursor])
+      cursor
+    end
+
+    def word_separator?(char)
+      char.to_s.match?(/\s/)
+    end
+  end
+end

data/lib/kward/tools/context_budget_stats.rb

@@ -0,0 +1,54 @@
+require_relative "base"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model-callable tool wrappers and their argument schemas.
+  module Tools
+    # Reports approximate context budget savings for the current process.
+    class ContextBudgetStats < Base
+      def initialize(context_budget_meter: nil)
+        @context_budget_meter = context_budget_meter
+        super(
+          "context_budget_stats",
+          "Return approximate per-session context budget savings from tool output compaction and deduplication.",
+          properties: {},
+          required: []
+        )
+      end
+
+      def call(_args, conversation, cancellation: nil)
+        cancellation&.raise_if_cancelled!
+        meter = conversation.respond_to?(:context_budget_meter) ? conversation.context_budget_meter : @context_budget_meter
+        return "Error: context budget stats are unavailable" unless meter
+
+        snapshot = meter.snapshot
+        lines = [
+          "# Context budget stats",
+          "- Calls: #{snapshot.calls}",
+          "- Original bytes: #{snapshot.original_bytes}",
+          "- Returned bytes: #{snapshot.returned_bytes}",
+          "- Saved bytes: #{snapshot.saved_bytes}",
+          "- Estimated tokens saved: #{estimated_tokens(snapshot.saved_bytes)}"
+        ]
+        lines.concat(tool_breakdown_lines(snapshot.tool_breakdown))
+        lines.join("\n")
+      end
+
+      private
+
+      def tool_breakdown_lines(tool_breakdown)
+        return [] if tool_breakdown.empty?
+
+        lines = ["", "## By tool"]
+        tool_breakdown.sort_by { |tool, data| [-data[:savedBytes], tool] }.each do |tool, data|
+          lines << "- #{tool}: #{data[:calls]} call(s), #{data[:savedBytes]} bytes saved, #{data[:returnedBytes]}/#{data[:originalBytes]} bytes returned"
+        end
+        lines
+      end
+
+      def estimated_tokens(bytes)
+        (bytes.to_i / 4.0).ceil
+      end
+    end
+  end
+end

data/lib/kward/tools/context_for_task.rb

@@ -0,0 +1,202 @@
+require "pathname"
+require_relative "../workspace"
+require_relative "base"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model-callable tool wrappers and their argument schemas.
+  module Tools
+    # Builds a compact, task-shaped bundle from likely workspace files.
+    class ContextForTask < Base
+      DEFAULT_BUDGET = 4_000
+      MAX_BUDGET = 20_000
+      MAX_FILES = 8
+      MAX_MATCHES_PER_FILE = 8
+      DEFAULT_EXTENSIONS = %w[.rb .js .jsx .ts .tsx .py .go .rs .java .cs .cpp .c .h .hpp .md .yml .yaml .json .toml].freeze
+      SKIP_DIRECTORIES = %w[.git .yardoc _yardoc node_modules vendor tmp log coverage dist build .bundle].freeze
+
+      # Builds the tool schema and stores the execution dependency.
+      def initialize(workspace:)
+        @workspace = workspace
+        super(
+          "context_for_task",
+          "Build focused workspace context for a task from outlines and matching excerpts within a byte budget.",
+          properties: {
+            budget: { type: "integer", description: "Approximate byte budget for the returned context. Default 4000, maximum 20000." },
+            paths: { type: "array", items: { type: "string" }, description: "Optional workspace-relative files or directories to focus." },
+            task: { type: "string", description: "Task or question to gather context for." }
+          },
+          required: ["task"]
+        )
+      end
+
+      # Executes focused context retrieval.
+      def call(args, _conversation, cancellation: nil)
+        cancellation&.raise_if_cancelled!
+        task = argument(args, :task, "").to_s.strip
+        return "Error: task is required" if task.empty?
+
+        budget = normalized_budget(argument(args, :budget))
+        return budget if budget.is_a?(String)
+
+        focus_paths = Array(argument(args, :paths, [])).map(&:to_s).reject(&:empty?)
+        files = candidate_files(focus_paths, cancellation: cancellation)
+        return "No readable candidate files found for focused context." if files.empty?
+
+        terms = search_terms(task)
+        ranked = rank_files(files, terms)
+        render_context(task: task, budget: budget, terms: terms, ranked: ranked, cancellation: cancellation)
+      rescue SecurityError, Errno::ENOENT => e
+        "Error: #{e.message}"
+      end
+
+      private
+
+      def normalized_budget(value)
+        return DEFAULT_BUDGET if value.nil?
+
+        budget = value.to_i
+        return "Error: budget must be positive" unless budget.positive?
+
+        [budget, MAX_BUDGET].min
+      end
+
+      def candidate_files(paths, cancellation:)
+        roots = paths.empty? ? [@workspace.root.to_s] : paths.map { |path| @workspace.resolved_path(path) }
+        files = roots.flat_map do |path|
+          cancellation&.raise_if_cancelled!
+          File.directory?(path) ? files_under(path, cancellation: cancellation) : [path]
+        end
+        files.uniq.select { |path| readable_context_file?(path) }.first(MAX_FILES * 8)
+      end
+
+      def files_under(root, cancellation:)
+        files = []
+        stack = [root]
+        until stack.empty? || files.length >= MAX_FILES * 8
+          cancellation&.raise_if_cancelled!
+          current = stack.pop
+          next if skipped_directory?(current)
+
+          entries = Dir.children(current).sort.map { |entry| File.join(current, entry) }
+          entries.each do |entry|
+            if File.directory?(entry)
+              stack << entry
+            else
+              files << entry if readable_context_file?(entry)
+            end
+          end
+        end
+        files
+      end
+
+      def readable_context_file?(path)
+        return false unless File.file?(path)
+        return false if File.size(path) > Workspace::MAX_FILE_BYTES
+        return false unless DEFAULT_EXTENSIONS.include?(File.extname(path)) || File.basename(path) == "Gemfile"
+
+        sample = File.open(path, "rb") { |file| file.read(4096).to_s }
+        !sample.include?("\x00")
+      rescue Errno::ENOENT, Errno::EACCES
+        false
+      end
+
+      def skipped_directory?(path)
+        SKIP_DIRECTORIES.include?(File.basename(path))
+      end
+
+      def search_terms(task)
+        task.scan(/[A-Za-z_][A-Za-z0-9_]{2,}/).map(&:downcase).reject { |term| stopword?(term) }.uniq.first(20)
+      end
+
+      def stopword?(term)
+        %w[the and for with from this that into when where what why how fix add update change implement review debug explain failing failure error issue].include?(term)
+      end
+
+      def rank_files(files, terms)
+        scored = files.map do |path|
+          content = File.read(path)
+          relative = relative_path(path)
+          score = score_file(relative, content, terms)
+          { path: path, relative: relative, content: content, score: score }
+        rescue Errno::ENOENT, Errno::EACCES
+          nil
+        end.compact
+        filtered = terms.empty? ? scored : scored.select { |file| file[:score].positive? }
+        filtered.sort_by { |file| [-file[:score], file[:relative]] }.first(MAX_FILES)
+      end
+
+      def score_file(relative, content, terms)
+        haystack = "#{relative}\n#{content}".downcase
+        terms.sum { |term| haystack.scan(term).length } + (terms.any? { |term| relative.downcase.include?(term) } ? 5 : 0)
+      end
+
+      def render_context(task:, budget:, terms:, ranked:, cancellation:)
+        lines = ["# Focused context", "- Task: #{task}", "- Budget: #{budget} bytes", "- Search terms: #{terms.empty? ? '(none)' : terms.join(', ')}", ""]
+        used = lines.join("\n").bytesize
+
+        ranked.each do |file|
+          cancellation&.raise_if_cancelled!
+          section = file_section(file, terms)
+          break if used + section.bytesize > budget && lines.length > 5
+
+          if used + section.bytesize > budget
+            remaining = budget - used
+            break if remaining < 200
+
+            section = section.byteslice(0, remaining).to_s.scrub << "\n[Context budget reached.]"
+          end
+          lines << section
+          used += section.bytesize
+        end
+
+        lines.join("\n")
+      end
+
+      def file_section(file, terms)
+        outline = @workspace.summarize_file_structure(file[:relative])
+        matches = matching_excerpt(file[:content], terms)
+        parts = ["## #{file[:relative]}", "- Score: #{file[:score]}"]
+        parts << outline unless outline.start_with?("No recognizable source structure")
+        parts << matches unless matches.empty?
+        parts.join("\n") << "\n"
+      end
+
+      def matching_excerpt(content, terms)
+        return "" if terms.empty?
+
+        lines = content.split("\n", -1)
+        indexes = matching_indexes(lines, terms)
+        return "" if indexes.empty?
+
+        selected = indexes.flat_map { |index| ([index - 2, 0].max..[index + 2, lines.length - 1].min).to_a }.uniq.sort
+        render_excerpt(lines, selected)
+      end
+
+      def matching_indexes(lines, terms)
+        indexes = []
+        lines.each_with_index do |line, index|
+          lower = line.downcase
+          indexes << index if terms.any? { |term| lower.include?(term) }
+          break if indexes.length >= MAX_MATCHES_PER_FILE
+        end
+        indexes
+      end
+
+      def render_excerpt(lines, selected)
+        output = ["### Matching excerpts"]
+        previous = nil
+        selected.each do |index|
+          output << "..." if previous && index > previous + 1
+          output << "%4d: %s" % [index + 1, lines[index]]
+          previous = index
+        end
+        output.join("\n")
+      end
+
+      def relative_path(path)
+        Pathname.new(path).relative_path_from(@workspace.root).to_s
+      end
+    end
+  end
+end

data/lib/kward/tools/read_file.rb

@@ -11,11 +11,13 @@ module Kward
         @workspace = workspace
         super(
           "read_file",
-          "Read a workspace text file. Output is capped; use offset/limit to continue.",
+          "Read a workspace text file. Output is capped; use offset/limit or mode to control context budget.",
           properties: {
             path: { type: "string", description: "Workspace-relative path." },
-            offset: { type: "integer", description: "1-indexed start line." },
-            limit: { type: "integer", description: "Maximum lines to return." }
+            limit: { type: "integer", description: "Maximum lines to return." },
+            max_bytes: { type: "integer", description: "Optional byte budget for this read, capped by Kward's workspace read limit." },
+            mode: { type: "string", enum: %w[preview outline range full], description: "Context mode. preview returns a short slice, outline returns source declarations, range reads offset/limit, full reads until Kward's cap." },
+            offset: { type: "integer", description: "1-indexed start line." }
           },
           required: ["path"]
         )
@@ -26,7 +28,9 @@ module Kward
         path = argument(args, :path, "")
         offset = argument(args, :offset)
         limit = argument(args, :limit)
-        content = @workspace.read_file(path, offset: offset, limit: limit)
+        mode = argument(args, :mode)
+        max_bytes = argument(args, :max_bytes)
+        content = @workspace.read_file(path, offset: offset, limit: limit, mode: mode, max_bytes: max_bytes)
         conversation.mark_read(@workspace.resolved_path(path)) unless content.start_with?("Error:")
         content
       end