kward 0.71.0 → 0.72.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,95 @@ 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)
+      end
+
+      def build_ekwsh(agent)
+        config = ConfigFiles.read_ekwsh_config
+        Ekwsh.new(cwd: interactive_workspace_root(agent), configured_env: config[:env], aliases: config[:aliases])
+      end
+
+      def run_ekwsh_loop(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.output.to_s.empty?
+          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.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 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) { @prompt.ask(shell.prompt_label) }
+        else
+          @prompt.ask(shell.prompt_label)
+        end
+      end
+
+      def run_ekwsh_command(shell, input)
+        if @prompt.respond_to?(:begin_busy_input)
+          @prompt.begin_busy_input(shell.prompt_label, activity: "running")
+        end
+        shell.run(input)
+      ensure
+        @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+      end
+
       def configured_workspace(root: current_workspace_root)
         Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
       end
@@ -146,10 +276,10 @@ 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)
+        conversation.update_runtime_context!(provider: current_model_provider, model: current_model_id, reasoning_effort: reasoning_effort, refresh: refresh_system_message)
         update_assistant_prompt(conversation)
       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,123 @@ 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)
+          conversation.persist_runtime_context! if conversation&.respond_to?(:persist_runtime_context!)
+          @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|