kward 0.71.0 → 0.72.0

data/lib/kward/cli.rb

@@ -13,6 +13,7 @@ require_relative "cli_transcript_formatter"
 require_relative "model/context_usage"
 require_relative "events"
 require_relative "export_path"
+require_relative "ekwsh"
 require_relative "auth/anthropic_oauth"
 require_relative "auth/github_oauth"
 require_relative "auth/openrouter_api_key"
@@ -29,10 +30,12 @@ require_relative "model/retry_message"
 require_relative "rpc/server"
 require_relative "session_diff"
 require_relative "session_store"
+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 +51,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 +65,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 +83,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 +105,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 +174,28 @@ 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 == "count-tests"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("count-tests")
+          return
+        end
+        raise ArgumentError, command_usage("count-tests") unless @argv.length == 1
+
+        print_test_count
+        return
+      end
+
       if @argv.first == "sysprompt"
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("sysprompt")
@@ -181,7 +213,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 +263,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 +376,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)
+        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 +416,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 +475,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/config_files.rb

@@ -1,7 +1,9 @@
+require "digest"
 require "fileutils"
 require "json"
 require "yaml"
 require_relative "private_file"
+require_relative "editor_mode"
 require_relative "prompts/templates"
 require_relative "skills/registry"
 
@@ -64,6 +66,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 +78,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 +116,15 @@ 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)
+      key = Digest::SHA256.hexdigest(canonical_workspace_root(cwd))[0, 24]
+      File.join(config_dir, "history", "#{key}.jsonl")
+    end
+
     # @return [String] directory containing structured memory files
     def memory_dir
       File.join(config_dir, "memory")
@@ -144,6 +168,50 @@ module Kward
       PrivateFile.write_json(path, config)
     end
 
+    def read_ekwsh_config(path = ekwsh_config_path)
+      path = File.expand_path(path)
+      return { env: {}, aliases: {} } 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 : {}
+      {
+        env: normalize_ekwsh_env(settings["env"]),
+        aliases: normalize_ekwsh_aliases(settings["aliases"])
+      }
+    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 name.match?(/\A[A-Za-z0-9_.:-]+\z/)
+        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 +222,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 +272,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

data/lib/kward/conversation.rb

@@ -1,5 +1,6 @@
 require "digest"
 require "set"
+require_relative "context_budget_meter"
 require_relative "image_attachments"
 require_relative "message_access"
 require_relative "plugin_registry"
@@ -60,6 +61,8 @@ module Kward
     attr_reader :last_plugin_prompt_context
     # @return [Hash] original large tool outputs retained outside model context
     attr_reader :tool_output_artifacts
+    # @return [ContextBudgetMeter] runtime context savings for this conversation
+    attr_reader :context_budget_meter
 
     def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil)
       @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
@@ -89,6 +92,7 @@ module Kward
       @session_memories = Array(session_memories)
       @last_memory_retrieval = last_memory_retrieval
       @tool_output_artifacts = {}
+      @context_budget_meter = ContextBudgetMeter.new
       @messages.concat(transcript_messages)
       @read_paths = Set.new(read_paths)
       @on_append = on_append
@@ -146,6 +150,10 @@ module Kward
     end
 
     def store_tool_output_artifact(tool_name:, content:)
+      restore_tool_output_artifact(tool_name: tool_name, content: content, created_at: Time.now.utc)
+    end
+
+    def restore_tool_output_artifact(tool_name:, content:, created_at: nil)
       text = self.class.normalize_tool_content(content)
       id = tool_output_artifact_id_for(tool_name: tool_name, content: text)
       @tool_output_artifacts[id] = {
@@ -153,7 +161,7 @@ module Kward
         tool_name: tool_name,
         content: text,
         bytes: text.bytesize,
-        created_at: Time.now.utc
+        created_at: created_at || Time.now.utc
       }
       id
     end
@@ -186,11 +194,11 @@ module Kward
       replacement
     end
 
-    def update_runtime_context!(provider: nil, model:, reasoning_effort:)
+    def update_runtime_context!(provider: nil, model:, reasoning_effort:, refresh: true)
       @provider = provider unless provider.to_s.empty?
       @model = model
       @reasoning_effort = reasoning_effort
-      refresh_system_message!
+      refresh_system_message! if refresh
     end
 
     def persist_runtime_context!
@@ -270,7 +278,7 @@ module Kward
     end
 
     def prompt_time
-      Time.at(0)
+      Time.now
     end
 
     def workspace_agents_mtime

data/lib/kward/editor_mode.rb

@@ -0,0 +1,25 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Normalizes built-in TUI file editor mode names.
+  module EditorMode
+    MODES = %w[modern emacs vibe].freeze
+    DEFAULT = "modern".freeze
+    LINE_NUMBER_MODES = %w[absolute relative].freeze
+    DEFAULT_LINE_NUMBERS = "absolute".freeze
+
+    module_function
+
+    def normalize(value)
+      text = value.to_s.downcase
+      return DEFAULT if text == "default"
+      return "vibe" if text == "vi"
+
+      MODES.include?(text) ? text : DEFAULT
+    end
+
+    def normalize_line_numbers(value)
+      text = value.to_s.downcase
+      LINE_NUMBER_MODES.include?(text) ? text : DEFAULT_LINE_NUMBERS
+    end
+  end
+end