kward 0.71.0 → 0.73.0

data/lib/kward/cli/tool_summaries.rb

@@ -21,6 +21,8 @@ module Kward
           shell_command_summary(args, text)
         when "web_search"
           web_search_summary(args, text)
+        when "read_skill"
+          read_skill_summary(text)
         else
           generic_tool_summary(name, text)
         end
@@ -76,6 +78,10 @@ module Kward
         lines.join("\n")
       end
 
+      def read_skill_summary(content)
+        "read_skill:\n#{content}"
+      end
+
       def error_tool_summary(name, args, content)
         path = args["path"] || args[:path]
         command = args["command"] || args[:command]

data/lib/kward/cli.rb

@@ -9,10 +9,13 @@ require_relative "model/client"
 require_relative "compactor"
 require_relative "config_files"
 require_relative "clipboard"
+require_relative "cancellation"
 require_relative "cli_transcript_formatter"
 require_relative "model/context_usage"
 require_relative "events"
 require_relative "export_path"
+require_relative "ekwsh"
+require_relative "interactive_pty_runner"
 require_relative "auth/anthropic_oauth"
 require_relative "auth/github_oauth"
 require_relative "auth/openrouter_api_key"
@@ -29,10 +32,13 @@ require_relative "model/retry_message"
 require_relative "rpc/server"
 require_relative "session_diff"
 require_relative "session_store"
+require_relative "session_naming"
+require_relative "tab_store"
 require_relative "session_trash"
 require_relative "session_tree_renderer"
 require_relative "starter_pack_installer"
 require_relative "steering"
+require_relative "workers"
 require_relative "tools/tool_call"
 require_relative "tools/registry"
 require_relative "telemetry/stats"
@@ -48,10 +54,12 @@ require_relative "cli/slash_commands"
 require_relative "cli/memory_commands"
 require_relative "cli/settings"
 require_relative "cli/sessions"
+require_relative "cli/tabs"
 require_relative "cli/compaction"
 require_relative "cli/rendering"
 require_relative "cli/prompt_interface"
 require_relative "cli/plugins"
+require_relative "cli/git"
 require_relative "cli/interactive_turn"
 require_relative "cli/tool_summaries"
 
@@ -60,8 +68,6 @@ module Kward
   # Command-line interface for interactive chat, one-shot prompts, login,
   # telemetry export, Pan server mode, and the experimental JSON-RPC backend.
   class CLI
-    # Order from the captain: The next line shall never be deleted.
-    STATUS_MESSAGE = "This is a totally important status message about a non-existing status. Hi ChatGPT 👋"
     RESTORED_TOOL_OUTPUT_LIMIT = 2_000
     INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT = 10
     STREAM_RENDER_INTERVAL = 0.025
@@ -80,10 +86,12 @@ module Kward
     include CLI::MemoryCommands
     include CLI::Settings
     include CLI::Sessions
+    include CLI::Tabs
     include CLI::CompactionCommands
     include CLI::Rendering
     include CLI::PromptInterfaceSupport
     include CLI::Plugins
+    include CLI::GitCommands
     include CLI::InteractiveTurn
     include CLI::ToolSummaries
 
@@ -100,6 +108,11 @@ module Kward
       @plugin_registry = nil
       @working_directory = nil
       @prompt_delimited = false
+      @requested_mode = "auto"
+      @experimental_workers = false
+      @foreground_turn_active = false
+      @pending_reasoning_config = nil
+      @pending_reasoning_config_mutex = Mutex.new
       @color_enabled = ANSI.enabled?($stdout)
     end
 
@@ -164,6 +177,17 @@ module Kward
         return
       end
 
+      if @argv.first == "edit"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("edit")
+          return
+        end
+        raise ArgumentError, command_usage("edit") unless @argv.length == 2
+
+        edit_file_command(@argv[1])
+        return
+      end
+
       if @argv.first == "sysprompt"
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("sysprompt")
@@ -181,7 +205,7 @@ module Kward
         end
         raise ArgumentError, command_usage("rpc") unless @argv.length == 1
 
-        Kward::RPC::Server.new(input: @stdin, output: $stdout, client: @client).run
+        Kward::RPC::Server.new(input: @stdin, output: $stdout, client: @client, experimental_workers: @experimental_workers).run
         return
       end
 
@@ -231,53 +255,107 @@ module Kward
       run_prompt_or_interactive
     end
 
+    def edit_file_command(path)
+      setup_interactive_prompt
+      unless @prompt.respond_to?(:edit_file)
+        raise ArgumentError, "The integrated editor requires an interactive terminal."
+      end
+
+      @prompt.edit_file(path, base_dir: Dir.pwd, allow_new: true)
+    ensure
+      @prompt.close if @prompt.respond_to?(:close) && prompt_interface?
+    end
+
     def run_prompt_or_interactive
+      stdin_input = read_stdin_input
       first_prompt = one_shot_prompt_argument
-      if first_prompt
-        answer = one_shot(first_prompt)
-        puts answer unless answer.empty?
-        return
-      end
 
-      stdin_prompt = piped_prompt
-      unless stdin_prompt.empty?
-        answer = one_shot(stdin_prompt)
+      case resolved_execution_mode(first_prompt: first_prompt, stdin_input: stdin_input)
+      when "chat"
+        interactive_loop
+      when "filter"
+        raise ArgumentError, "Filter mode requires stdin input." if stdin_input.nil?
+
+        answer = one_shot(filter_prompt(instruction: first_prompt, input: stdin_input), filter: true)
+        puts answer unless answer.empty?
+      when "oneshot"
+        input = first_prompt || stdin_input.to_s.strip
+        answer = one_shot(input)
         puts answer unless answer.empty?
-        return
       end
-
-      interactive_loop
     end
 
-    def one_shot(input)
+    def one_shot(input, filter: false)
       streamed = false
       assistant_streamed = false
       markdown_chunks = []
       conversation = new_conversation
+      apply_filter_system_prompt(conversation) if filter
       agent = Agent.new(
         client: @client,
         tool_registry: ToolRegistry.new(workspace: configured_workspace, prompt: @prompt),
         conversation: conversation
       )
-      answer = agent.ask(input) do |event|
-        result = render_blocking_turn_event(event, markdown_chunks)
-        streamed = true if result
-        assistant_streamed = true if result == :assistant_streamed
+      answer = if filter
+        agent.ask(input)
+      else
+        agent.ask(input) do |event|
+          result = render_blocking_turn_event(event, markdown_chunks)
+          streamed = true if result
+          assistant_streamed = true if result == :assistant_streamed
+        end
       end
       flush_markdown_deltas(markdown_chunks) if streamed
+      return answer if filter
+
       assistant_streamed ? "" : render_markdown_transcript(answer)
     end
 
+    def resolved_execution_mode(first_prompt:, stdin_input:)
+      return @requested_mode unless @requested_mode == "auto"
+      return "chat" if stdin_input.nil? && first_prompt.nil?
+      return "filter" if !stdin_input.nil? && first_prompt
+
+      "oneshot"
+    end
+
+    def filter_prompt(instruction:, input:)
+      <<~PROMPT
+        Instruction:
+        #{instruction}
+
+        Input:
+        #{input}
+      PROMPT
+    end
 
+    def apply_filter_system_prompt(conversation)
+      return unless conversation.system_message
+
+      conversation.system_message[:content] = [conversation.system_message[:content], filter_system_prompt].compact.join("\n\n")
+    end
 
+    def filter_system_prompt
+      <<~PROMPT.strip
+        You are being used as a command-line text filter.
 
+        Transform the provided input according to the user's instruction.
+        Return only the transformed output.
 
+        Do not include explanations, introductions, summaries, Markdown fences, or commentary.
+        Do not say what you changed.
+        Preserve the input format unless the instruction requires changing it.
+        If the input is code, data, markup, or configuration, output only the resulting code/data/markup/configuration.
+      PROMPT
+    end
 
     def interactive_loop(agent: nil)
       setup_interactive_prompt
       session_store = interactive_session_store(agent)
       @resumed_last_session = false
-      if session_store && agent.nil?
+      if session_store && @prompt.respond_to?(:update_tabs)
+        agent = setup_interactive_tabs(session_store, agent)
+      elsif session_store && agent.nil?
         agent = resume_last_session(session_store) || build_new_session_agent(session_store)
       elsif session_store
         @active_session = track_session(session_store.create(provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort))
@@ -290,13 +368,29 @@ module Kward
       update_assistant_prompt(agent.conversation)
       @footer_conversation = agent.conversation
 
-      print_visual_banner unless @resumed_last_session
+      print_visual_banner unless @resumed_last_session || @restored_tabs
       render_resumed_last_session_transcript(agent.conversation) if @resumed_last_session
 
       @pending_inputs = []
 
       loop do
-        input = @pending_inputs.shift || @prompt.ask("You>")
+        if @pending_inputs.empty? && active_tab&.shell
+          run_ekwsh_loop(active_tab.shell, tab: active_tab, history: build_ekwsh_history(active_tab.agent))
+        end
+        input = @pending_inputs.shift || (active_tab ? poll_active_tab_input : @prompt.ask("You>"))
+        if input.is_a?(Hash) && input[:tab_action]
+          tab_result = handle_tab_action(input, session_store)
+          break if tab_result == PromptInterface::EXIT_INPUT
+          agent = active_tab.agent if active_tab
+          next
+        end
+        if input.is_a?(Hash) && input[:reasoning_action]
+          conversation = active_tab ? active_tab.agent.conversation : agent.conversation
+          cycle_reasoning(conversation, direction: input[:reasoning_action], persist: :debounced)
+          agent = active_tab.agent if active_tab
+          next
+        end
+        next if input == :tab_idle
         break if input.nil?
 
         display_input = submitted_display_input(input)
@@ -314,31 +408,57 @@ module Kward
           end
           break if ["/exit", "/quit"].include?(command)
           handled, replacement_agent = handle_local_slash_command(command, agent, session_store)
-          agent = replacement_agent if replacement_agent
+          if replacement_agent?(replacement_agent)
+            agent = active_tab ? replace_active_tab_agent(replacement_agent) : replacement_agent
+          end
         end
         next if handled
+        request_handled, request_replacement = handle_request_worker_input(command_input, agent, session_store)
+        if request_handled
+          if replacement_agent?(request_replacement)
+            agent = active_tab ? replace_active_tab_agent(request_replacement) : request_replacement
+          end
+          next
+        end
         next if shell_command_input?(command_input) && handle_interactive_shell_command(command_input, agent)
 
+        flush_pending_reasoning_config(conversation: agent.conversation)
         expanded_input = expand_prompt_template(input)
         display_input = display_input || input if expanded_input
         input = expanded_input || input
+        agent = refresh_implementation_writer(agent)
         @footer_conversation = agent.conversation
         begin
           @rewind_return_leaf_id = nil
           auto_name_active_session(display_input || input)
-          pending_inputs = run_interactive_turn(agent, input, display_input: display_input)
+          @foreground_turn_active = true if @active_worker_role == "implementation"
+          if active_tab
+            submit_tab_input(active_tab, input, display_input: display_input)
+            pending_inputs = []
+          else
+            pending_inputs = run_interactive_turn(agent, input, display_input: display_input)
+            agent = @busy_replacement_agent if replacement_agent?(@busy_replacement_agent)
+            @busy_replacement_agent = nil
+          end
           pending_inputs.reverse_each { |pending_input| @pending_inputs.unshift(pending_input) }
         rescue StandardError => e
           runtime_output("Error: #{e.message}")
+        ensure
+          @foreground_turn_active = false if @active_worker_role == "implementation"
+          release_implementation_writer if @active_worker_role == "implementation"
         end
       end
 
+      flush_pending_reasoning_config(conversation: agent.conversation)
       agent.conversation
     rescue Interrupt
+      flush_pending_reasoning_config(conversation: agent&.conversation)
       runtime_output("Goodbye.")
       agent&.conversation
     ensure
       begin
+        stop_tabs if respond_to?(:stop_tabs, true)
+        stop_live_worker_view if respond_to?(:stop_live_worker_view, true)
         @prompt.close if prompt_interface?
       ensure
         cleanup_unused_sessions
@@ -347,9 +467,13 @@ module Kward
     end
 
     def piped_prompt
-      return "" if @stdin.tty?
+      read_stdin_input.to_s.strip
+    end
+
+    def read_stdin_input
+      return nil if @stdin.tty?
 
-      @stdin.read.strip
+      @stdin.read
     end
 
   end

data/lib/kward/clipboard.rb

@@ -1,5 +1,5 @@
-require "base64"
 require "open3"
+require_relative "terminal_sequences"
 require "rbconfig"
 
 # Namespace for the Kward CLI agent runtime.
@@ -39,8 +39,7 @@ module Kward
     end
 
     def write_osc52(content)
-      encoded = Base64.strict_encode64(content)
-      @output.print("\e]52;c;#{encoded}\a")
+      @output.print(TerminalSequences.osc52(content))
       @output.flush if @output.respond_to?(:flush)
     end
 

data/lib/kward/compactor.rb

@@ -130,8 +130,7 @@ module Kward
       end
 
       def tool_calls(message)
-        calls = value(message, :tool_calls)
-        calls.is_a?(Array) ? calls : []
+        MessageAccess.tool_calls(message)
       end
 
       def tool_call_name(tool_call)
@@ -335,7 +334,7 @@ module Kward
 
       def tool_call_args(tool_call)
         function = tool_call["function"] || tool_call[:function] || {}
-        parse_tool_arguments(function["arguments"] || function[:arguments])
+        ToolCall.parse_arguments(function["arguments"] || function[:arguments])
       end
 
       def tool_command(tool_call)
@@ -351,15 +350,6 @@ module Kward
           "#{name}(#{rendered})"
         end
       end
-
-      def parse_tool_arguments(arguments)
-        return {} if arguments.nil? || arguments.empty?
-        return arguments if arguments.is_a?(Hash)
-
-        JSON.parse(arguments)
-      rescue JSON::ParserError
-        {}
-      end
     end
 
     # Compaction support object used by conversation summarization.
@@ -441,7 +431,7 @@ module Kward
       end
 
       def message_role(message)
-        message["role"] || message[:role]
+        MessageAccess.role(message)
       end
     end
 
@@ -518,22 +508,20 @@ module Kward
       end
 
       def compaction_summary(message)
-        message["summary"] || message[:summary] || message["content"] || message[:content]
+        MessageAccess.summary(message) || MessageAccess.content(message)
       end
 
       def compaction_details(message)
-        return {} unless message
-
-        details = message["details"] || message[:details]
+        details = MessageAccess.value(message, :details)
         details.is_a?(Hash) ? details : {}
       end
 
       def entry_id(message, index)
-        message["id"] || message[:id] || "message:#{index}"
+        MessageAccess.value(message, :id) || "message:#{index}"
       end
 
       def message_role(message)
-        message["role"] || message[:role]
+        MessageAccess.role(message)
       end
     end
 

data/lib/kward/config_files.rb

@@ -1,7 +1,10 @@
+require "digest"
 require "fileutils"
 require "json"
 require "yaml"
 require_relative "private_file"
+require_relative "ekwsh"
+require_relative "editor_mode"
 require_relative "prompts/templates"
 require_relative "skills/registry"
 
@@ -64,6 +67,10 @@ module Kward
       File.join(config_dir, "cache")
     end
 
+    def ekwsh_config_path
+      File.join(config_dir, "ekwsh.yml")
+    end
+
     def default_config
       {
         "personas" => JSON.parse(JSON.generate(DEFAULT_PERSONAS)),
@@ -72,7 +79,16 @@ module Kward
           "auto_summary" => false
         },
         "composer" => {
-          "busy_help" => true
+          "busy_help" => true,
+          "tab_keybindings" => "auto"
+        },
+        "editor" => {
+          "mode" => "modern",
+          "auto_indent" => true,
+          "auto_close_pairs" => true,
+          "soft_wrap" => true,
+          "bar_cursor" => true,
+          "line_numbers" => "absolute"
         },
         "sessions" => {
           "auto_resume" => false
@@ -101,6 +117,17 @@ module Kward
       File.join(cache_dir, "openrouter_models.json")
     end
 
+    def project_browser_state_path
+      File.join(cache_dir, "project_browser_state.json")
+    end
+
+    def prompt_history_path(cwd, config_dir: self.config_dir, kind: "prompt")
+      key = Digest::SHA256.hexdigest(canonical_workspace_root(cwd))[0, 24]
+      return File.join(config_dir, "history", "#{key}.jsonl") if kind.to_s == "prompt"
+
+      File.join(config_dir, "history", kind.to_s, "#{key}.jsonl")
+    end
+
     # @return [String] directory containing structured memory files
     def memory_dir
       File.join(config_dir, "memory")
@@ -144,6 +171,69 @@ module Kward
       PrivateFile.write_json(path, config)
     end
 
+    def read_ekwsh_config(path = ekwsh_config_path)
+      path = File.expand_path(path)
+      return normalize_ekwsh_config(nil) unless File.exist?(path)
+
+      data = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+      normalize_ekwsh_config(data)
+    rescue Psych::SyntaxError => e
+      raise "Invalid ekwsh YAML config: #{path}: #{e.message}"
+    end
+
+    def normalize_ekwsh_config(data)
+      data = data.transform_keys(&:to_s) if data.is_a?(Hash)
+      settings = data.is_a?(Hash) ? data : {}
+      {
+        shell: normalize_ekwsh_shell(settings["shell"]),
+        timeout_seconds: normalize_positive_integer(settings["timeout_seconds"], Ekwsh::DEFAULT_TIMEOUT_SECONDS),
+        max_output_bytes: normalize_positive_integer(settings["max_output_bytes"], Ekwsh::DEFAULT_MAX_OUTPUT_BYTES),
+        history_limit: normalize_positive_integer(settings["history_limit"], Ekwsh::DEFAULT_HISTORY_LIMIT),
+        env: normalize_ekwsh_env(settings["env"]),
+        aliases: normalize_ekwsh_aliases(settings["aliases"])
+      }
+    end
+
+    def normalize_ekwsh_shell(value)
+      shell = value.to_s.strip
+      return Ekwsh::DEFAULT_SHELL if shell.empty?
+      return shell if shell.start_with?("/") && File.executable?(shell)
+
+      Ekwsh::DEFAULT_SHELL
+    end
+
+    def normalize_positive_integer(value, default)
+      integer = Integer(value)
+      integer.positive? ? integer : default
+    rescue ArgumentError, TypeError
+      default
+    end
+
+    def normalize_ekwsh_env(values)
+      return {} unless values.is_a?(Hash)
+
+      values.each_with_object({}) do |(key, value), result|
+        key = key.to_s
+        next unless key.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+        next if value.nil?
+
+        result[key] = value.to_s
+      end
+    end
+
+    def normalize_ekwsh_aliases(values)
+      return {} unless values.is_a?(Hash)
+
+      values.each_with_object({}) do |(name, command), result|
+        name = name.to_s
+        command = command.to_s.strip
+        next unless Ekwsh.valid_alias_name?(name)
+        next if command.empty?
+
+        result[name] = command
+      end
+    end
+
     # Merges top-level config values and writes the updated config privately.
     def update_config(values, path = config_path)
       raise "Config values must be an object" unless values.is_a?(Hash)
@@ -154,6 +244,17 @@ module Kward
       config
     end
 
+    # Merges values into a one-level nested config section and writes privately.
+    def update_nested_config(section, values, path = config_path)
+      raise "Config values must be an object" unless values.is_a?(Hash)
+
+      config = read_config(path)
+      current = config[section.to_s].is_a?(Hash) ? config[section.to_s].dup : {}
+      config[section.to_s] = current.merge(values.transform_keys(&:to_s))
+      write_config(config, path)
+      config
+    end
+
     # Removes a top-level config key when it exists.
     def delete_config_key(key, path = config_path)
       config = read_config(path)
@@ -193,6 +294,49 @@ module Kward
       composer["busy_help"] != false
     end
 
+    # Returns the configured tab keybinding family, or auto when unset/invalid.
+    def composer_tab_keybindings(config = read_config)
+      composer = config["composer"].is_a?(Hash) ? config["composer"] : {}
+      value = composer["tab_keybindings"].to_s.downcase
+      %w[auto ctrl alt].include?(value) ? value : "auto"
+    end
+
+    # Returns the built-in TUI editor keymap mode.
+    def editor_mode(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      EditorMode.normalize(editor["mode"])
+    end
+
+    # Returns whether the built-in TUI editor should auto-indent new lines.
+    def editor_auto_indent?(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      editor["auto_indent"] != false
+    end
+
+    # Returns whether the built-in TUI editor should auto-close typed pairs.
+    def editor_auto_close_pairs?(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      editor["auto_close_pairs"] != false
+    end
+
+    # Returns whether the built-in TUI editor should soft-wrap long lines.
+    def editor_soft_wrap?(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      editor["soft_wrap"] != false
+    end
+
+    # Returns whether editable built-in TUI editor buffers should use a bar cursor.
+    def editor_bar_cursor?(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      editor["bar_cursor"] != false
+    end
+
+    # Returns the built-in TUI editor line-number display mode.
+    def editor_line_numbers(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      EditorMode.normalize_line_numbers(editor["line_numbers"])
+    end
+
     # Returns whether file tools must stay inside the active workspace root.
     def workspace_guardrails_enabled?(config = read_config)
       tools = config["tools"].is_a?(Hash) ? config["tools"] : {}

data/lib/kward/context_budget_meter.rb

@@ -0,0 +1,44 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Tracks approximate context bytes saved by tool budgeting during one process.
+  class ContextBudgetMeter
+    Snapshot = Struct.new(:calls, :original_bytes, :returned_bytes, :saved_bytes, :tool_breakdown, keyword_init: true)
+
+    def initialize
+      @mutex = Mutex.new
+      @calls = 0
+      @original_bytes = 0
+      @returned_bytes = 0
+      @tool_breakdown = Hash.new { |hash, key| hash[key] = { calls: 0, originalBytes: 0, returnedBytes: 0, savedBytes: 0 } }
+    end
+
+    def record(tool_name:, original_bytes:, returned_bytes:)
+      original_bytes = original_bytes.to_i
+      returned_bytes = returned_bytes.to_i
+      saved_bytes = [original_bytes - returned_bytes, 0].max
+      @mutex.synchronize do
+        @calls += 1
+        @original_bytes += original_bytes
+        @returned_bytes += returned_bytes
+        entry = @tool_breakdown[tool_name.to_s]
+        entry[:calls] += 1
+        entry[:originalBytes] += original_bytes
+        entry[:returnedBytes] += returned_bytes
+        entry[:savedBytes] += saved_bytes
+      end
+      saved_bytes
+    end
+
+    def snapshot
+      @mutex.synchronize do
+        Snapshot.new(
+          calls: @calls,
+          original_bytes: @original_bytes,
+          returned_bytes: @returned_bytes,
+          saved_bytes: [@original_bytes - @returned_bytes, 0].max,
+          tool_breakdown: @tool_breakdown.transform_values(&:dup)
+        )
+      end
+    end
+  end
+end