kward 0.83.0 → 0.84.0

data/lib/kward/cli/tabs.rb

@@ -33,9 +33,11 @@ module Kward
         :markdown_chunks,
         :label,
         :unread,
+        :attention,
         :pending_question,
         :shell,
         :shell_agent,
+        :background_run,
         :transient_shell_entries,
         :error_reported,
         :local_busy_activity,
@@ -106,6 +108,10 @@ module Kward
           @cli.send(:ask_tab_user_question, @tab, questions, cancellation: cancellation)
         end
 
+        def edit_file(path, base_dir:, allow_new:)
+          @cli.send(:open_editor_for_agent, path, base_dir: base_dir, allow_new: allow_new)
+        end
+
         def ask_tool_approval(tool_name:, args:, reason: nil)
           answers = ask_user_question([
             {
@@ -316,9 +322,11 @@ module Kward
           markdown_chunks: [],
           label: label,
           unread: false,
+          attention: nil,
           pending_question: nil,
           shell: nil,
           shell_agent: nil,
+          background_run: nil,
           transient_shell_entries: [],
           error_reported: false,
           local_busy_activity: nil
@@ -420,14 +428,14 @@ module Kward
         end
 
         if @tabs.length <= 1
-          close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
+          close_kwsh_session(tab.shell) if tab&.shell && respond_to?(:close_kwsh_session, true)
           @tabs.clear
           persist_tabs
           return PromptInterface::EXIT_INPUT
         end
 
         stop_tab_live_view
-        close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
+        close_kwsh_session(tab.shell) if tab&.shell && respond_to?(:close_kwsh_session, true)
         tab.session&.delete_if_unused if tab&.session.respond_to?(:delete_if_unused)
         tab.driver.close if tab.driver.respond_to?(:close)
         @tabs.delete_at(@active_tab_index)
@@ -461,12 +469,13 @@ module Kward
         tab.error = nil
         tab.answer = nil
         tab.unread = false
+        tab.attention = nil
         tab.error_reported = false
         tab.event_history.clear
         tab.seen_events = 0
         tab.queued_inputs.clear
         tab.steering = nil
-        close_ekwsh_session(tab.shell) if tab.shell && respond_to?(:close_ekwsh_session, true)
+        close_kwsh_session(tab.shell) if tab.shell && respond_to?(:close_kwsh_session, true)
         tab.shell = nil
         tab.shell_agent = nil
         tab.clear_transient_shell_entries
@@ -501,6 +510,7 @@ module Kward
       end
 
       def activate_tab(index, render: true)
+        service_background_tab_runs
         tab = @tabs[index]
         return nil unless tab
 
@@ -517,6 +527,7 @@ module Kward
           @prompt.update_assistant_label(assistant_prompt_name) if @prompt.respond_to?(:update_assistant_label)
         end
         tab.unread = false
+        tab.attention = nil
         restore_tab_composer_snapshot(tab.snapshot)
         update_prompt_workspace_root(current_workspace_root)
         @prompt.refresh_composer_status if @prompt.respond_to?(:refresh_composer_status)
@@ -603,6 +614,44 @@ module Kward
         index ? index + 1 : active_tab_number
       end
 
+      def register_background_tab_run(tab, run, &completion)
+        return unless tab && run
+
+        tab.background_run = { run: run, completion: completion }
+        tab.local_busy_activity = "running"
+        tab.attention = nil
+        update_prompt_tabs
+      end
+
+      def service_background_tab_runs
+        return unless @tabs
+
+        @tabs.each do |tab|
+          state = tab.background_run
+          next unless state&.fetch(:run)&.complete?
+
+          result = state[:run].result
+          tab.background_run = nil
+          state[:completion]&.call(state[:run].sink, result) if result.is_a?(Struct)
+          finish_local_busy_command_for_tab(tab)
+          if tab != active_tab
+            tab.unread = true
+            tab.attention = :success
+          end
+        rescue StandardError => e
+          tab.background_run = nil
+          tab.error = e.message
+          finish_local_busy_command_for_tab(tab)
+          tab.attention = :failure if tab != active_tab
+        end
+        update_prompt_tabs
+      end
+
+      def finish_local_busy_command_for_tab(tab)
+        tab.local_busy_activity = nil
+        @prompt.finish_busy_input if prompt_interface? && tab == active_tab && @prompt.respond_to?(:finish_busy_input)
+      end
+
       def submit_tab_input(tab, input, display_input: nil)
         return if input.to_s.strip.empty?
 
@@ -616,6 +665,7 @@ module Kward
         print_user_transcript(input, display_input: display_input) if prompt_interface?
         tab.status = "queued"
         tab.unread = false
+        tab.attention = nil
         tab.cancellation = Cancellation.new
         tab.steering = tab.driver.supports_steering? && steering_supported? ? Steering.new : nil
         tab.error = nil
@@ -639,14 +689,17 @@ module Kward
         end
         tab.status = "ready"
         tab.unread = tab != active_tab
+        tab.attention = :output if tab != active_tab
       rescue Cancellation::CancelledError
         tab.status = "cancelled"
         tab.unread = false
+        tab.attention = :failure if tab != active_tab
         report_tab_runtime_error(tab)
       rescue StandardError => e
         tab.error = e.message
         tab.status = "failed"
         tab.unread = false
+        tab.attention = :failure if tab != active_tab
         report_tab_runtime_error(tab)
       ensure
         finish_tab_turn(tab)
@@ -662,8 +715,9 @@ module Kward
       end
 
       def poll_active_tab_input
+        service_background_tab_runs
         tab = active_tab
-        unless tab&.running?
+        unless tab&.running? || tab&.local_busy?
           input = @prompt.ask("You>")
           return { tab_action: :close } if input.nil? && tab && @tabs.length > 1
 
@@ -672,6 +726,7 @@ module Kward
 
         @prompt.begin_busy_input("You>") if @prompt.respond_to?(:begin_busy_input)
         loop do
+          service_background_tab_runs
           refresh_active_tab
           if service_active_tab_question
             return next_tab_queued_input(tab) if tab.idle? && !tab.queued_inputs.empty?
@@ -679,6 +734,10 @@ module Kward
 
             next
           end
+          if @prompt.respond_to?(:modal_active?) && @prompt.modal_active?
+            sleep 0.01
+            next
+          end
           poll_result = @prompt.poll_input
           case poll_result
           when Hash
@@ -687,8 +746,12 @@ module Kward
               return poll_result
             end
           when PromptInterface::CANCEL_INPUT
-            tab.cancellation&.cancel!
-            tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
+            if tab.background_run
+              tab.background_run[:run].cancel!
+            else
+              tab.cancellation&.cancel!
+              tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
+            end
           when PromptInterface::EXIT_INPUT
             tab.queued_inputs << "/exit"
             @prompt.set_queued_count(tab.queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
@@ -830,15 +893,17 @@ module Kward
         return if tab.stream_state[:streamed]
         return if tab.answer.to_s.empty?
 
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(tab.answer)}\n")
+        @prompt.say("\n#{colored(transcript_marker("Assistant"), :activity, :bold)} #{render_markdown_transcript(tab.answer)}\n")
       end
 
       def new_tab_stream_state(driver)
         {
           streamed: false,
+          assistant_arrived: false,
           last_flush: monotonic_now,
           stream_block_open: false,
           markdown_streams: {},
+          tool_elapsed_ms: {},
           defer_assistant_streaming: driver.respond_to?(:conversation) && defer_assistant_streaming?(driver.agent)
         }
       end
@@ -853,10 +918,11 @@ module Kward
       end
 
       def tab_label_color(tab)
-        return :green if tab.status.to_s == "waiting_for_question"
-        return :yellow if tab.running? || tab.local_busy?
-        return :red if %w[failed cancelled].include?(tab.status.to_s)
-        return :green if tab.unread
+        return :success if tab.status.to_s == "waiting_for_question"
+        return :caution if tab.running? || tab.local_busy?
+        return :failure if %w[failed cancelled].include?(tab.status.to_s) || tab.attention == :failure
+        return :success if tab.attention == :success
+        return :activity if tab.unread
 
         nil
       end
@@ -970,7 +1036,12 @@ module Kward
             tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
             tab.thread&.join(0.2)
           end
-          close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
+          if (background_run = tab.background_run&.fetch(:run))
+            background_run.cancel!
+            background_run.join(0.5)
+          end
+          tab.background_run = nil
+          close_kwsh_session(tab.shell) if tab&.shell && respond_to?(:close_kwsh_session, true)
         rescue StandardError
           nil
         end

data/lib/kward/cli/tool_summaries.rb

@@ -6,6 +6,20 @@ module Kward
     module ToolSummaries
       private
 
+      def tool_activity(tool_call)
+        "running #{tool_call_name(tool_call).tr("_", " ")}"
+      end
+
+      def tool_summary_with_duration(summary, elapsed_ms)
+        return summary.to_s unless elapsed_ms
+
+        lines = summary.to_s.lines
+        first = lines.shift.to_s.chomp
+        duration = elapsed_ms < 1_000 ? "#{elapsed_ms.round} ms" : format("%.1f s", elapsed_ms / 1_000.0)
+        first = "#{first} · #{duration}"
+        lines.empty? ? first : (["#{first}\n"] + lines).join
+      end
+
       def tool_result_summary(tool_call, content)
         name = tool_call_name(tool_call)
         args = tool_call_args(tool_call)

data/lib/kward/cli.rb

@@ -18,7 +18,7 @@ require_relative "cli_transcript_formatter"
 require_relative "model/context_usage"
 require_relative "events"
 require_relative "export_path"
-require_relative "ekwsh"
+require_relative "kwsh"
 require_relative "persistent_shell_session"
 require_relative "interactive_pty_runner"
 require_relative "adaptive_pty_output_sink"
@@ -92,7 +92,7 @@ module Kward
     RESTORED_TOOL_OUTPUT_LIMIT = 2_000
     INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT = 10
     STREAM_RENDER_INTERVAL = 0.025
-    INTERACTIVE_EVENT_DRAIN_LIMIT = 100
+    INTERACTIVE_EVENT_DRAIN_LIMIT = 12
     BUILTIN_SLASH_COMMANDS = PromptCommands::BUILTIN_COMMANDS
     BUILTIN_SLASH_COMMAND_NAMES = PromptCommands::BUILTIN_RESERVED_COMMAND_NAMES
 
@@ -156,6 +156,16 @@ module Kward
       warn e.message
       warn "Run `kward help` for available commands."
       exit 1
+    rescue Client::AuthenticationError => e
+      raise if debug_errors?
+
+      warn authentication_error_message(e)
+      exit 1
+    rescue StandardError => e
+      raise if debug_errors?
+
+      warn runtime_error_message(e)
+      exit 1
     ensure
       ConfigFiles.skip_config = false
     end
@@ -184,6 +194,30 @@ module Kward
       MESSAGE
     end
 
+    def authentication_error_message(error)
+      <<~MESSAGE.rstrip
+        Authentication required
+
+        #{error.message}
+
+        Run `kward doctor` to inspect your setup.
+      MESSAGE
+    end
+
+    def runtime_error_message(error)
+      <<~MESSAGE.rstrip
+        Kward could not complete the request.
+
+        #{error.message}
+
+        Set KWARD_DEBUG=1 to show a backtrace.
+      MESSAGE
+    end
+
+    def debug_errors?
+      ENV["KWARD_DEBUG"] == "1"
+    end
+
     def dispatch
       if @prompt_delimited
         ConfigFiles.ensure_default_config!
@@ -229,7 +263,7 @@ module Kward
         raise ArgumentError, command_usage("doctor") unless @argv.length == 1
 
         ensure_client!
-        print_doctor
+        exit 1 unless print_doctor
         return
       end
 
@@ -239,7 +273,7 @@ module Kward
           return
         end
 
-        handle_hooks_command((@argv[1..] || []).join(" "))
+        handle_hooks_command((@argv[1..] || []).join(" "), command_line: true)
         return
       end
 
@@ -478,8 +512,9 @@ module Kward
       install_bang_completion_provider(agent)
 
       loop do
-        if @pending_inputs.empty? && active_tab&.shell
-          run_ekwsh_loop(active_tab.shell, tab: active_tab, history: build_ekwsh_history(active_tab.agent))
+        service_background_tab_runs if respond_to?(:service_background_tab_runs, true)
+        if @pending_inputs.empty? && active_tab&.shell && !active_tab.local_busy?
+          run_kwsh_loop(active_tab.shell, tab: active_tab, history: build_kwsh_history(active_tab.agent))
         end
         input = @pending_inputs.shift || (active_tab ? poll_active_tab_input : @prompt.ask("You>"))
         if input.is_a?(Hash) && input[:editor_prompt]
@@ -537,7 +572,10 @@ module Kward
           end
         end
         next if handled
-        next if shell_command_input?(command_input) && handle_interactive_shell_command(command_input, agent)
+        if shell_command_input?(command_input)
+          shell_result = handle_interactive_shell_command(command_input, agent)
+          next if shell_result == true || shell_result == :tab_action
+        end
 
         flush_pending_reasoning_config(conversation: active_tab.agent.conversation) if active_tab&.agent
         flush_pending_reasoning_config(conversation: agent.conversation) unless active_tab

data/lib/kward/cli_transcript_formatter.rb

@@ -15,10 +15,17 @@ module Kward
 
     def reasoning_blocks(message)
       response_blocks = response_items(message).flat_map do |item|
-        next [] unless MessageAccess.value(item, :type) == "reasoning"
-
-        summary = response_item_text_parts(MessageAccess.value(item, :summary))
-        summary.empty? ? response_item_text_parts(MessageAccess.value(item, :content)) : summary
+        case MessageAccess.value(item, :type)
+        when "reasoning"
+          summary = response_item_text_parts(MessageAccess.value(item, :summary))
+          summary.empty? ? response_item_text_parts(MessageAccess.value(item, :content)) : summary
+        when "message"
+          next [] unless MessageAccess.value(item, :phase).to_s == "commentary"
+
+          response_item_text_parts(MessageAccess.value(item, :content))
+        else
+          []
+        end
       end
       return response_blocks unless response_blocks.empty?
 

data/lib/kward/config_files.rb

@@ -1,14 +1,14 @@
 require "digest"
 require "fileutils"
 require "json"
-require "yaml"
 require_relative "frontmatter"
 require_relative "deep_copy"
 require_relative "private_file"
 require_relative "path_guard"
 require_relative "permissions/policy"
 require_relative "sandbox/policy"
-require_relative "ekwsh"
+require_relative "kwsh"
+require_relative "kwshrc"
 require_relative "editor_mode"
 require_relative "diff_view_mode"
 require_relative "prompts/templates"
@@ -107,9 +107,14 @@ module Kward
       File.join(config_dir, "cache")
     end
 
-    # @return [String] embedded-shell YAML config path
-    def ekwsh_config_path
-      File.join(config_dir, "ekwsh.yml")
+    # @return [String] embedded-shell rc config path
+    def kwshrc_path
+      File.join(config_dir, "kwshrc")
+    end
+
+    # @return [Array<String>] embedded-shell rc config paths in load order
+    def kwshrc_paths
+      [kwshrc_path, File.expand_path("~/.kwshrc")].uniq
     end
 
     def workspace_hooks_path(root = Dir.pwd)
@@ -137,6 +142,7 @@ module Kward
         "editor" => {
           "mode" => "modern",
           "agent" => {},
+          "runners" => {},
           "auto_indent" => true,
           "auto_close_pairs" => true,
           "soft_wrap" => true,
@@ -340,67 +346,25 @@ module Kward
       merged
     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"])
+    def read_kwsh_config
+      config = {
+        shell: Kwsh::DEFAULT_SHELL,
+        timeout_seconds: Kwsh::DEFAULT_TIMEOUT_SECONDS,
+        max_output_bytes: Kwsh::DEFAULT_MAX_OUTPUT_BYTES,
+        history_limit: Kwsh::DEFAULT_HISTORY_LIMIT,
+        env: {},
+        aliases: {}
       }
+      rc_config = read_kwshrc_config
+      config[:env].merge!(rc_config[:env])
+      config[:aliases].merge!(rc_config[:aliases])
+      config
     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
+    def read_kwshrc_config(paths = kwshrc_paths, env: ENV.to_h)
+      Kwshrc.read(paths, env: env)
+    rescue Kwshrc::ParseError => e
+      raise "Invalid kwshrc config: #{e.message}"
     end
 
     # Merges top-level config values and writes the updated config privately.
@@ -483,19 +447,69 @@ module Kward
       EditorMode.normalize(editor["mode"])
     end
 
+    # Returns configured editor runner definitions, or an empty map.
+    #
+    # Runner defaults are resolved by the editor runner at execution time so
+    # the generated config remains portable across machines.
+    def editor_runners(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      runners = editor["runners"]
+      runners.is_a?(Hash) ? runners : {}
+    end
+
+    # Returns the optional provider override for editor-agent turns.
+    def editor_agent_provider(config = read_config)
+      value = ENV["KWARD_EDITOR_PROVIDER"].to_s.strip
+      return value unless value.empty?
+
+      editor_agent_setting(config, "provider")
+    end
+
     # Returns the optional model override for editor-agent turns.
     def editor_agent_model(config = read_config)
-      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
-      agent = editor["agent"].is_a?(Hash) ? editor["agent"] : {}
-      value = agent["model"].to_s.strip
-      value.empty? ? nil : value
+      editor_agent_setting(config, "model")
     end
 
     # Returns the optional reasoning-effort override for editor-agent turns.
     def editor_agent_reasoning_effort(config = read_config)
+      editor_agent_setting(config, "reasoning_effort")
+    end
+
+    # Returns the shell-agent provider override, preferring the environment.
+    def shell_agent_provider(config = read_config)
+      value = ENV["KWSH_PROVIDER"].to_s.strip
+      return value unless value.empty?
+
+      shell_agent_setting(config, "provider")
+    end
+
+    # Returns the shell-agent model override, preferring the environment.
+    def shell_agent_model(config = read_config)
+      value = ENV["KWSH_MODE"].to_s.strip
+      return value unless value.empty?
+
+      shell_agent_setting(config, "model")
+    end
+
+    # Returns the shell-agent reasoning-effort override, preferring the environment.
+    def shell_agent_reasoning_effort(config = read_config)
+      value = ENV["KWSH_REASONING"].to_s.strip
+      return value unless value.empty?
+
+      shell_agent_setting(config, "reasoning_effort")
+    end
+
+    def editor_agent_setting(config, key)
       editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
       agent = editor["agent"].is_a?(Hash) ? editor["agent"] : {}
-      value = agent["reasoning_effort"].to_s.strip
+      value = agent[key].to_s.strip
+      value.empty? ? nil : value
+    end
+
+    def shell_agent_setting(config, key)
+      shell = config["shell"].is_a?(Hash) ? config["shell"] : {}
+      agent = shell["agent"].is_a?(Hash) ? shell["agent"] : {}
+      value = agent[key].to_s.strip
       value.empty? ? nil : value
     end
 

data/lib/kward/detached_run.rb

@@ -0,0 +1,44 @@
+require "thread"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Owns a command that continues after its terminal has been returned to Kward.
+  class DetachedRun
+    attr_reader :sink
+
+    def initialize(sink:, canceler: nil, &work)
+      @sink = sink
+      @canceler = canceler
+      @mutex = Mutex.new
+      @result = nil
+      @thread = Thread.new do
+        begin
+          result = work.call
+          @mutex.synchronize { @result = result }
+        rescue StandardError => e
+          @mutex.synchronize { @result = e }
+        end
+      end
+      @thread.report_on_exception = false
+    end
+
+    def complete?
+      !@thread.alive?
+    end
+
+    def result
+      return unless complete?
+
+      @thread.join
+      @mutex.synchronize { @result }
+    end
+
+    def join(timeout = nil)
+      @thread.join(timeout)
+    end
+
+    def cancel!
+      @canceler&.call
+    end
+  end
+end