kward 0.71.0 → 0.73.0

data/lib/kward/cli/runtime_helpers.rb

@@ -43,9 +43,22 @@ module Kward
       end
 
       def build_interactive_agent(conversation)
+        @active_worker_role = "implementation"
+        set_visible_worker("implementation", status: "active")
+        build_worker_agent(conversation, role: "implementation")
+      end
+
+      def build_worker_agent(conversation, role: "implementation")
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
         workspace = configured_workspace(root: conversation.workspace_root)
-        tool_registry = ToolRegistry.new(workspace: workspace, prompt: @prompt)
+        writer_id = worker_writer_id(role)
+        tool_registry = ToolRegistry.new(
+          workspace: workspace,
+          prompt: @prompt,
+          allowed_tool_names: Workers::ToolPolicy.allowed_tool_names(role),
+          write_lock: @worker_write_lock,
+          writer_id: writer_id
+        )
         @footer_conversation = conversation
         @footer_tool_registry = tool_registry
         Agent.new(
@@ -55,6 +68,34 @@ module Kward
         )
       end
 
+      def set_visible_worker(id, status: nil, worker: nil)
+        @visible_worker_id = id.to_s
+        @visible_worker_status = status
+        @visible_worker = worker
+      end
+
+      def worker_writer_id(role)
+        return nil unless Workers::ToolPolicy.write_capable?(role)
+
+        @worker_write_lock ||= Workers::WriteLock.new
+        owner_id = role.to_s.empty? ? "implementation" : role.to_s
+        return owner_id if @worker_write_lock.acquire(owner_id)
+
+        nil
+      end
+
+      def refresh_implementation_writer(agent)
+        return agent unless @active_worker_role == "implementation"
+        return agent unless agent&.respond_to?(:tool_registry)
+        return agent if agent.tool_registry.writer_id && @worker_write_lock&.owned_by?(agent.tool_registry.writer_id)
+
+        build_interactive_agent(agent.conversation)
+      end
+
+      def release_implementation_writer
+        @worker_write_lock&.release("implementation")
+      end
+
       def handle_interactive_shell_command(input, agent)
         command = input.to_s.sub(/\A!\s*/, "")
         if command.strip.empty?
@@ -73,6 +114,227 @@ module Kward
         input.to_s.start_with?("!")
       end
 
+      def run_ekwsh(agent)
+        unless @prompt.respond_to?(:ask)
+          runtime_output("The embedded shell is only available in interactive mode.")
+          return
+        end
+
+        tab = active_tab if respond_to?(:active_tab, true)
+        entering = tab.nil? || tab.shell.nil?
+        shell = tab&.shell || build_ekwsh(agent)
+        tab.shell = shell if tab
+        runtime_output("Entering ekwsh. Type exit or press Ctrl+D on an empty prompt to return.") if entering
+        run_ekwsh_loop(shell, tab: tab, history: build_ekwsh_history(agent))
+      end
+
+      def build_ekwsh(agent)
+        config = ConfigFiles.read_ekwsh_config
+        Ekwsh.new(
+          cwd: interactive_workspace_root(agent),
+          configured_env: config[:env],
+          aliases: config[:aliases],
+          shell: config[:shell],
+          timeout_seconds: config[:timeout_seconds],
+          max_output_bytes: config[:max_output_bytes]
+        )
+      end
+
+      def build_ekwsh_history(agent)
+        config = ConfigFiles.read_ekwsh_config
+        PromptHistory.new(
+          cwd: interactive_workspace_root(agent),
+          limit: config[:history_limit],
+          kind: "shell"
+        )
+      end
+
+      def run_interactive_pty_command(command, agent)
+        command = command.to_s.strip
+        if command.empty?
+          runtime_output("Usage: /pty <command>")
+          return
+        end
+
+        config = ConfigFiles.read_ekwsh_config
+        env = interactive_pty_environment(config[:env])
+        cwd = interactive_workspace_root(agent)
+        @prompt.say("$ #{command}\n[interactive PTY session started]\n") if @prompt.respond_to?(:say)
+        result = run_interactive_pty_with_terminal_handoff(config[:shell], command, env: env, cwd: cwd)
+        @prompt.say("[interactive PTY session exited with status #{result.exit_status}]\n") if @prompt.respond_to?(:say)
+      rescue Errno::ENOENT => e
+        runtime_output("Error: #{e.message}")
+      end
+
+      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:)
+        runner = InteractivePtyRunner.new
+        if @prompt.respond_to?(:with_terminal_handoff)
+          @prompt.with_terminal_handoff do |input, output|
+            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output)
+          end
+        else
+          runner.run(shell, "-c", command, env: env, cwd: cwd)
+        end
+      end
+
+      def interactive_pty_environment(configured_env)
+        ENV.to_h.merge(configured_env.to_h.transform_keys(&:to_s).transform_values(&:to_s)).tap do |env|
+          env.delete("GIT_PAGER") if env["GIT_PAGER"] == "cat"
+          env["TERM"] = "xterm-256color" if env["TERM"].to_s.empty? || env["TERM"] == "dumb"
+        end
+      end
+
+      def run_ekwsh_loop(shell, tab: nil, history: nil)
+        with_ekwsh_history(history) do
+          run_ekwsh_loop_with_history(shell, tab: tab)
+        end
+      end
+
+      def run_ekwsh_loop_with_history(shell, tab: nil)
+        loop do
+          if @prompt.respond_to?(:editing_file?) && @prompt.editing_file?
+            editor_result = @prompt.run_editor
+            if editor_result.is_a?(Hash) && editor_result[:tab_action]
+              (@pending_inputs ||= []).unshift(editor_result)
+              return :tab_action
+            end
+          end
+
+          input = ask_ekwsh(shell)
+          if input.is_a?(Hash) && input[:tab_action]
+            (@pending_inputs ||= []).unshift(input)
+            return :tab_action
+          end
+          break if input.nil?
+
+          result = run_ekwsh_command(shell, input)
+          @prompt.clear_transcript if result.clear && @prompt.respond_to?(:clear_transcript)
+          @prompt.say(result.output) unless result.streamed || result.interactive_command || result.output.to_s.empty?
+          return :tab_action if pending_tab_action?
+
+          if result.open_editor_path
+            editor_result = open_ekwsh_editor(result.open_editor_path, shell)
+            return :tab_action if editor_result == :tab_action
+
+            next
+          end
+          if result.interactive_command
+            run_ekwsh_interactive_pty_command(shell, result)
+            next
+          end
+          if result.exit_shell
+            tab.shell = nil if tab
+            runtime_output("Shell exited.")
+            return :exited
+          end
+        end
+        tab.shell = nil if tab
+        runtime_output("Shell exited.")
+        :exited
+      end
+
+      def with_ekwsh_history(history)
+        if history && @prompt.respond_to?(:with_prompt_history)
+          @prompt.with_prompt_history(history) { yield }
+        else
+          yield
+        end
+      end
+
+      def open_ekwsh_editor(path, shell)
+        unless @prompt.respond_to?(:edit_file)
+          runtime_output("Integrated editor is unavailable in this prompt.")
+          return false
+        end
+
+        result = @prompt.edit_file(path, base_dir: shell.cwd, allow_new: true)
+        if result.is_a?(Hash) && result[:tab_action]
+          (@pending_inputs ||= []).unshift(result)
+          return :tab_action
+        end
+
+        result
+      end
+
+      def ask_ekwsh(shell)
+        provider = ->(input, cursor) { shell.complete(input, cursor) }
+        if @prompt.respond_to?(:with_completion_provider)
+          @prompt.with_completion_provider(provider, slash_overlay: false) { @prompt.ask(shell.prompt_label) }
+        else
+          @prompt.ask(shell.prompt_label)
+        end
+      end
+
+      def run_ekwsh_interactive_pty_command(shell, result)
+        @prompt.say(result.output) unless result.output.to_s.empty?
+        pty_result = run_interactive_pty_with_terminal_handoff(
+          shell.command_shell,
+          result.interactive_command,
+          env: shell.child_env(interactive: true),
+          cwd: shell.cwd
+        )
+        @prompt.say("[interactive PTY session exited with status #{pty_result.exit_status}]\n") if @prompt.respond_to?(:say)
+      end
+
+      def run_ekwsh_command(shell, input)
+        if @prompt.respond_to?(:begin_busy_input)
+          @prompt.begin_busy_input(shell.prompt_label, activity: "running")
+        end
+        if @prompt.respond_to?(:write_transcript_delta) && @prompt.respond_to?(:poll_input)
+          run_streaming_ekwsh_command(shell, input)
+        elsif @prompt.respond_to?(:write_transcript_delta)
+          shell.run(input) { |chunk| @prompt.write_transcript_delta(chunk) }
+        else
+          shell.run(input)
+        end
+      ensure
+        @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+      end
+
+      def run_streaming_ekwsh_command(shell, input)
+        cancellation = Cancellation.new
+        chunks = Queue.new
+        queued_inputs = []
+        result = nil
+        error = nil
+        worker = Thread.new do
+          result = shell.run(input, cancellation: cancellation) { |chunk| chunks << chunk }
+        rescue StandardError => e
+          error = e
+        end
+        worker.report_on_exception = false
+
+        while worker.alive?
+          drain_ekwsh_chunks(chunks)
+          poll_result = collect_queued_input(queued_inputs)
+          if poll_result == PromptInterface::CANCEL_INPUT
+            cancellation.cancel!
+          elsif poll_result.is_a?(Hash) && poll_result[:tab_action]
+            (@pending_inputs ||= []).unshift(poll_result)
+            cancellation.cancel!
+          end
+          sleep 0.01
+        end
+        worker.join
+        drain_ekwsh_chunks(chunks)
+        raise error if error
+
+        queued_inputs.reverse_each { |pending_input| (@pending_inputs ||= []).unshift(pending_input) }
+        result
+      end
+
+      def drain_ekwsh_chunks(chunks)
+        loop do
+          @prompt.write_transcript_delta(chunks.pop(true))
+        rescue ThreadError
+          break
+        end
+      end
+
+      def pending_tab_action?
+        @pending_inputs&.first.is_a?(Hash) && @pending_inputs.first[:tab_action]
+      end
+
       def configured_workspace(root: current_workspace_root)
         Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
       end
@@ -146,10 +408,12 @@ module Kward
         @client.reload_config if @client.respond_to?(:reload_config)
       end
 
-      def refresh_conversation_runtime(conversation)
+      def refresh_conversation_runtime(conversation, reasoning_effort: current_reasoning_effort, refresh_system_message: true)
         return unless conversation&.respond_to?(:update_runtime_context!)
 
-        conversation.update_runtime_context!(provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        runtime_changed = [conversation.provider, conversation.model, conversation.reasoning_effort] != [current_model_provider, current_model_id, reasoning_effort]
+        conversation.update_runtime_context!(provider: current_model_provider, model: current_model_id, reasoning_effort: reasoning_effort, refresh: refresh_system_message)
+        conversation.persist_runtime_context! if runtime_changed && conversation.respond_to?(:persist_runtime_context!)
         update_assistant_prompt(conversation)
       end
 
@@ -162,7 +426,7 @@ module Kward
       end
 
       def default_session_name(input)
-        input.to_s.gsub(/\s+/, " ").strip.slice(0, 120).to_s
+        SessionNaming.default_name(input)
       end
 
     end

data/lib/kward/cli/sessions.rb

@@ -12,7 +12,7 @@ module Kward
         return @session_store if @session_store
         return nil if agent
 
-        SessionStore.new
+        @session_store = SessionStore.new
       end
 
       def resume_last_session(session_store)
@@ -69,7 +69,7 @@ module Kward
       end
 
       def mutation_tool_call?(tool_call)
-        ["edit_file", "write_file", "edit", "write"].include?(ToolCall.name(tool_call).to_s)
+        ToolCall.file_change_tool?(ToolCall.name(tool_call))
       end
 
       def cleanup_unused_sessions

data/lib/kward/cli/settings.rb

@@ -222,6 +222,21 @@ module Kward
         when /\Ashow busy help/, /\Ahide busy help/
           set_composer_busy_help(!composer_busy_help?)
           runtime_output("Busy help #{composer_busy_help? ? "enabled" : "disabled"}. Restart the TUI to apply this setting.")
+        when /\Atab keybindings/
+          configure_tab_keybindings
+        when /\Aeditor mode/
+          configure_editor_mode
+        when /\Aeditor line numbers/
+          configure_editor_line_numbers
+        when /\Aenable auto-close pairs/, /\Adisable auto-close pairs/
+          set_editor_auto_close_pairs_enabled(!editor_auto_close_pairs_enabled?)
+          runtime_output("Editor auto-close pairs #{editor_auto_close_pairs_enabled? ? "enabled" : "disabled"}.")
+        when /\Aenable soft-wrap/, /\Adisable soft-wrap/
+          set_editor_soft_wrap_enabled(!editor_soft_wrap_enabled?)
+          runtime_output("Editor soft-wrap #{editor_soft_wrap_enabled? ? "enabled" : "disabled"}.")
+        when /\Aenable bar cursor/, /\Adisable bar cursor/
+          set_editor_bar_cursor_enabled(!editor_bar_cursor_enabled?)
+          runtime_output("Editor bar cursor #{editor_bar_cursor_enabled? ? "enabled" : "disabled"}.")
         when /\Aenable session auto-resume/, /\Adisable session auto-resume/
           set_session_auto_resume_enabled(!session_auto_resume_enabled?)
           runtime_output("Session auto-resume #{session_auto_resume_enabled? ? "enabled" : "disabled"}.")
@@ -234,6 +249,12 @@ module Kward
           "Overlay alignment (#{settings["alignment"]})",
           "Overlay width (#{settings["width"]})",
           "#{composer_busy_help? ? "Hide" : "Show"} busy help (currently #{on_off(composer_busy_help?)})",
+          "Tab keybindings (#{composer_tab_keybindings})",
+          "Editor mode (#{editor_mode})",
+          "Editor line numbers (#{editor_line_numbers})",
+          "#{editor_auto_close_pairs_enabled? ? "Disable" : "Enable"} auto-close pairs (currently #{on_off(editor_auto_close_pairs_enabled?)})",
+          "#{editor_soft_wrap_enabled? ? "Disable" : "Enable"} soft-wrap (currently #{on_off(editor_soft_wrap_enabled?)})",
+          "#{editor_bar_cursor_enabled? ? "Disable" : "Enable"} bar cursor (currently #{on_off(editor_bar_cursor_enabled?)})",
           "#{session_auto_resume_enabled? ? "Disable" : "Enable"} session auto-resume (currently #{on_off(session_auto_resume_enabled?)})",
           "Back"
         ]
@@ -243,6 +264,84 @@ module Kward
         ConfigFiles.composer_busy_help?(safely_read_config.to_h)
       end
 
+      def composer_tab_keybindings
+        ConfigFiles.composer_tab_keybindings(safely_read_config.to_h)
+      end
+
+      def configure_tab_keybindings
+        selected = @prompt.select("Tab keybindings", tab_keybinding_choices, title: "Settings")
+        value = selected.to_s.split.first.to_s.downcase
+        return unless %w[auto ctrl alt].include?(value)
+
+        update_nested_config("composer", "tab_keybindings" => value)
+        runtime_output("Tab keybindings set to #{value}. Restart the TUI to apply this setting.")
+      end
+
+      def tab_keybinding_choices
+        current = composer_tab_keybindings
+        %w[auto ctrl alt].map { |value| value == current ? "#{value} (current)" : value }
+      end
+
+      def editor_mode
+        ConfigFiles.editor_mode(safely_read_config.to_h)
+      end
+
+      def configure_editor_mode
+        selected = @prompt.select("Editor mode", editor_mode_choices, title: "Settings")
+        value = selected.to_s.split.first.to_s.downcase
+        return unless %w[modern emacs vibe].include?(value)
+
+        update_nested_config("editor", "mode" => value)
+        runtime_output("Editor mode set to #{value}. New editor buffers will use this mode.")
+      end
+
+      def editor_mode_choices
+        current = editor_mode
+        %w[modern emacs vibe].map { |value| value == current ? "#{value} (current)" : value }
+      end
+
+      def editor_line_numbers
+        ConfigFiles.editor_line_numbers(safely_read_config.to_h)
+      end
+
+      def configure_editor_line_numbers
+        selected = @prompt.select("Editor line numbers", editor_line_number_choices, title: "Settings")
+        value = selected.to_s.split.first.to_s.downcase
+        return unless %w[absolute relative].include?(value)
+
+        update_nested_config("editor", "line_numbers" => value)
+        runtime_output("Editor line numbers set to #{value}.")
+      end
+
+      def editor_line_number_choices
+        current = editor_line_numbers
+        %w[absolute relative].map { |value| value == current ? "#{value} (current)" : value }
+      end
+
+      def editor_auto_close_pairs_enabled?
+        ConfigFiles.editor_auto_close_pairs?(safely_read_config.to_h)
+      end
+
+      def set_editor_auto_close_pairs_enabled(enabled)
+        update_nested_config("editor", "auto_close_pairs" => enabled)
+      end
+
+      def editor_soft_wrap_enabled?
+        ConfigFiles.editor_soft_wrap?(safely_read_config.to_h)
+      end
+
+      def set_editor_soft_wrap_enabled(enabled)
+        update_nested_config("editor", "soft_wrap" => enabled)
+      end
+
+      def editor_bar_cursor_enabled?
+        ConfigFiles.editor_bar_cursor?(safely_read_config.to_h)
+      end
+
+      def set_editor_bar_cursor_enabled(enabled)
+        update_nested_config("editor", "bar_cursor" => enabled)
+      end
+
       def session_auto_resume_enabled?
         ConfigFiles.session_auto_resume_enabled?(safely_read_config.to_h)
       end
@@ -455,11 +554,7 @@ module Kward
       end
 
       def update_nested_config(section, values)
-        config = ConfigFiles.read_config
-        current = config[section].is_a?(Hash) ? config[section].dup : {}
-        config[section] = current.merge(values)
-        ConfigFiles.write_config(config)
-        config
+        ConfigFiles.update_nested_config(section, values)
       end
 
       def on_off(value)
@@ -526,10 +621,7 @@ module Kward
         effort, = choices.find { |_value, label| selected.to_s.downcase.start_with?(label.downcase) }
         raise "Reasoning effort must be one of: #{choices.map(&:first).join(", ")}" unless effort
 
-        ConfigFiles.update_config(ModelInfo.reasoning_config_key_for_provider(current_model_provider) => effort)
-        reload_client_config
-        refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        set_reasoning_effort(effort, conversation, provider: provider)
       rescue StandardError => e
         runtime_output("Reasoning error: #{e.message}")
       end
@@ -609,6 +701,122 @@ module Kward
         end
       end
 
+      REASONING_CONFIG_DEBOUNCE_SECONDS = 0.5
+
+      def cycle_reasoning(conversation = current_footer_conversation, direction: :next, persist: :immediate)
+        provider = conversation&.provider || current_model_provider
+        model = conversation&.model || current_model_id
+        choices = ModelInfo.reasoning_effort_choices(provider, model)
+        return false if choices.empty?
+
+        current = (pending_reasoning_effort(provider) || conversation&.reasoning_effort || current_reasoning_effort).to_s
+        current_index = choices.index { |effort, _label| effort == current }
+        current_index ||= direction == :previous ? 0 : -1
+        offset = direction == :previous ? -1 : 1
+        effort = choices[(current_index + offset) % choices.length].first
+        persist == :debounced ? apply_reasoning_effort(effort, conversation, provider: provider) : set_reasoning_effort(effort, conversation, provider: provider)
+        true
+      rescue StandardError => e
+        runtime_output("Reasoning error: #{e.message}")
+        false
+      end
+
+      def set_reasoning_effort(effort, conversation = nil, provider: nil)
+        @pending_reasoning_config_mutex.synchronize { @pending_reasoning_config = nil }
+        persist_reasoning_config(effort, provider: provider)
+        apply_reasoning_effort(effort, conversation, provider: provider, queue_config: false)
+      end
+
+      def apply_reasoning_effort(effort, conversation = nil, provider: nil, queue_config: true)
+        queue_reasoning_config(effort, provider: provider, conversation: conversation) if queue_config
+        if queue_config
+          update_conversation_reasoning_effort(conversation, effort)
+          refresh_reasoning_status
+        else
+          refresh_conversation_runtime(conversation, reasoning_effort: effort)
+          @prompt.redraw if @prompt.respond_to?(:redraw)
+        end
+      end
+
+      def refresh_reasoning_status
+        if @prompt.respond_to?(:refresh_composer_status)
+          @prompt.refresh_composer_status
+        else
+          @prompt.redraw if @prompt.respond_to?(:redraw)
+        end
+      end
+
+      def update_conversation_reasoning_effort(conversation, effort)
+        return unless conversation&.respond_to?(:update_runtime_context!)
+
+        conversation.update_runtime_context!(
+          provider: conversation.provider || current_model_provider,
+          model: conversation.model || current_model_id,
+          reasoning_effort: effort,
+          refresh: false
+        )
+      end
+
+      def pending_reasoning_effort(provider)
+        @pending_reasoning_config_mutex.synchronize do
+          pending = @pending_reasoning_config
+          return nil unless pending
+          return nil unless pending[:provider].to_s.downcase == provider.to_s.downcase
+
+          pending[:effort]
+        end
+      end
+
+      def queue_reasoning_config(effort, provider: nil, conversation: nil)
+        pending = {
+          effort: effort,
+          provider: provider || current_model_provider,
+          conversation: conversation,
+          deadline: Process.clock_gettime(Process::CLOCK_MONOTONIC) + REASONING_CONFIG_DEBOUNCE_SECONDS
+        }
+        @pending_reasoning_config_mutex.synchronize { @pending_reasoning_config = pending }
+        schedule_reasoning_config_flush
+      end
+
+      def schedule_reasoning_config_flush
+        return if @pending_reasoning_config_thread&.alive?
+
+        @pending_reasoning_config_thread = Thread.new do
+          loop do
+            sleep REASONING_CONFIG_DEBOUNCE_SECONDS
+            break if flush_pending_reasoning_config(force: false)
+            break unless @pending_reasoning_config_mutex.synchronize { @pending_reasoning_config }
+          end
+        rescue StandardError => e
+          runtime_output("Reasoning error: #{e.message}")
+        end
+      end
+
+      def flush_pending_reasoning_config(force: true, conversation: nil)
+        pending = nil
+        @pending_reasoning_config_mutex.synchronize do
+          pending = @pending_reasoning_config
+          return false unless pending
+
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          return false if !force && now < pending[:deadline].to_f
+
+          @pending_reasoning_config = nil
+        end
+        persist_reasoning_config(pending[:effort], provider: pending[:provider])
+        conversation ||= pending[:conversation]
+        if conversation&.reasoning_effort.to_s == pending[:effort].to_s
+          refresh_conversation_runtime(conversation, reasoning_effort: pending[:effort])
+          conversation.persist_runtime_context! if conversation.respond_to?(:persist_runtime_context!)
+        end
+        true
+      end
+
+      def persist_reasoning_config(effort, provider: nil)
+        ConfigFiles.update_config(ModelInfo.reasoning_config_key_for_provider(provider || current_model_provider) => effort)
+        reload_client_config
+      end
+
       def reasoning_choices(choices, conversation = current_footer_conversation)
         current = (conversation.reasoning_effort || (@client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : ModelInfo::DEFAULT_REASONING_EFFORT)).to_s
         choices.map do |effort, label|