kward 0.70.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,9 +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"
@@ -41,15 +45,18 @@ require_relative "cli/auth_commands"
 require_relative "cli/doctor"
 require_relative "cli/sysprompt"
 require_relative "cli/stats"
+require_relative "cli/openrouter_commands"
 require_relative "cli/runtime_helpers"
 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"
 
@@ -58,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
@@ -72,15 +77,18 @@ module Kward
     include CLI::Doctor
     include CLI::Sysprompt
     include CLI::Stats
+    include CLI::OpenRouterCommands
     include CLI::RuntimeHelpers
     include CLI::SlashCommands
     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
 
@@ -97,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
 
@@ -161,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")
@@ -178,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
 
@@ -193,6 +228,16 @@ module Kward
         return
       end
 
+      if @argv.first == "openrouter"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("openrouter")
+          return
+        end
+
+        handle_openrouter_command(@argv[1..] || [])
+        return
+      end
+
       if pan_mode?
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("pan")
@@ -218,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))
@@ -277,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)
@@ -301,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
@@ -334,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/compactor.rb

@@ -665,7 +665,10 @@ module Kward
         ## Critical Context
         - [Preserve important context, add new context needed to continue]
 
-        Keep each section concise. Preserve exact file paths, class names, module names, method names, constants, commands, spec names, migration names, error messages, user requirements, and unresolved problems. Do not invent work that did not happen.
+        ## Available Tool Artifacts
+        - [Preserve any toolout_* ids from compacted tool outputs, with what each id contains and why it may matter]
+
+        Keep each section concise. Preserve exact file paths, class names, module names, method names, constants, commands, spec names, migration names, error messages, toolout_* artifact ids, user requirements, and unresolved problems. Do not invent work that did not happen.
       PROMPT
 
       SPLIT_TURN_PROMPT = <<~PROMPT.strip.freeze

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
@@ -97,6 +112,19 @@ module Kward
       File.join(cache_dir, "code_search")
     end
 
+    def openrouter_models_cache_path
+      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")
@@ -140,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)
@@ -150,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)
@@ -189,10 +272,47 @@ module Kward
       composer["busy_help"] != false
     end
 
-    # Returns whether the terminal startup banner should be displayed.
-    def banner_enabled?(config = read_config)
-      banner = config["banner"].is_a?(Hash) ? config["banner"] : {}
-      banner["enabled"] != false
+    # 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.

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