kward 0.83.0 → 0.84.0

data/lib/kward/cli/runtime_helpers.rb

@@ -102,19 +102,19 @@ module Kward
         if editor_result
           record_tab_transient_shell_output(editor_result.output, render: false)
           @prompt.say(editor_result.output) unless editor_result.output.to_s.empty?
-          open_ekwsh_editor(editor_result.open_editor_path, shell) if editor_result.open_editor_path
+          open_kwsh_editor(editor_result.open_editor_path, shell) if editor_result.open_editor_path
           return true
         end
 
         expanded_command = shell.expand_alias(command, interactive: true)
-        run_user_interactive_pty_command(
+        result = run_user_interactive_pty_command(
           expanded_command,
-          shell: Ekwsh::DEFAULT_SHELL,
-          env: interactive_pty_environment({}, preserve_git_pager: true),
+          shell: Kwsh::DEFAULT_SHELL,
+          env: interactive_pty_environment(shell.child_env, preserve_git_pager: true),
           cwd: interactive_workspace_root(agent),
           intro: "$ #{command}\n"
         )
-        true
+        result&.tab_action ? :tab_action : true
       end
 
       def run_captured_shell_command(command, agent)
@@ -142,7 +142,7 @@ module Kward
         completion = bang_shell(agent).complete(value[1..], cursor.to_i - 1)
         return nil unless completion
 
-        Ekwsh::Completion.new(
+        Kwsh::Completion.new(
           range: (completion.range.begin + 1)...(completion.range.end + 1),
           replacement: completion.replacement,
           candidates: completion.candidates
@@ -151,12 +151,14 @@ module Kward
 
       def bang_shell(agent)
         root = File.expand_path(interactive_workspace_root(agent).to_s)
-        aliases = ConfigFiles.read_ekwsh_config[:aliases]
-        cache_key = [root, ENV.fetch("PATH", ""), aliases.sort]
+        config = ConfigFiles.read_kwsh_config
+        aliases = config[:aliases]
+        configured_env = config[:env]
+        cache_key = [root, ENV.fetch("PATH", ""), aliases.sort, configured_env.sort]
         return @bang_shell if @bang_shell_key == cache_key
 
         @bang_shell_key = cache_key
-        @bang_shell = Ekwsh.new(cwd: root, env: ENV.to_h, aliases: aliases)
+        @bang_shell = Kwsh.new(cwd: root, env: ENV.to_h, configured_env: configured_env, aliases: aliases)
       end
 
       def install_bang_completion_provider(agent)
@@ -182,7 +184,7 @@ module Kward
         @bang_completion_provider_installed = false
       end
 
-      def run_ekwsh(agent)
+      def run_kwsh(agent)
         unless @prompt.respond_to?(:ask)
           runtime_output("The embedded shell is only available in interactive mode.")
           return
@@ -190,11 +192,11 @@ module Kward
 
         tab = active_tab if respond_to?(:active_tab, true)
         entering = tab.nil? || tab.shell.nil?
-        shell = tab&.shell || build_ekwsh(agent)
+        shell = tab&.shell || build_kwsh(agent)
         tab.shell = shell if tab
         shell_agent = shell_prompt_agent_for(agent, tab: 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), shell_agent: shell_agent)
+        runtime_output("Entering kwsh. Type exit or press Ctrl+D on an empty prompt to return.") if entering
+        run_kwsh_loop(shell, tab: tab, history: build_kwsh_history(agent), shell_agent: shell_agent)
       end
 
       def shell_prompt_agent_for(agent, tab: nil)
@@ -208,17 +210,20 @@ module Kward
 
       def build_shell_prompt_agent(active_agent)
         active_conversation = active_agent.conversation
+        config = ConfigFiles.read_config
+        configured_provider = ConfigFiles.shell_agent_provider(config)
         conversation = Conversation.new(
           system_message: ShellPrompt.system_message,
           workspace_root: active_conversation.workspace_root,
-          provider: active_conversation.provider || current_model_provider,
-          model: active_conversation.model || current_model_id,
-          reasoning_effort: active_conversation.reasoning_effort || current_reasoning_effort
+          provider: configured_provider || active_conversation.provider || current_model_provider,
+          model: ConfigFiles.shell_agent_model(config) || (configured_provider ? nil : active_conversation.model || current_model_id),
+          reasoning_effort: ConfigFiles.shell_agent_reasoning_effort(config) || (configured_provider ? nil : active_conversation.reasoning_effort || current_reasoning_effort)
         )
         Agent.new(
           client: @client,
           tool_registry: active_agent.tool_registry,
           conversation: conversation,
+          strict_provider: !configured_provider.nil?,
           warning_sink: ConfigFiles.warning_sink
         )
       end
@@ -269,8 +274,8 @@ module Kward
         input.to_s.start_with?("?")
       end
 
-      def build_ekwsh(agent)
-        config = ConfigFiles.read_ekwsh_config
+      def build_kwsh(agent)
+        config = ConfigFiles.read_kwsh_config
         PersistentShellSession.new(
           cwd: interactive_workspace_root(agent),
           configured_env: config[:env],
@@ -281,8 +286,8 @@ module Kward
         )
       end
 
-      def build_ekwsh_history(agent)
-        config = ConfigFiles.read_ekwsh_config
+      def build_kwsh_history(agent)
+        config = ConfigFiles.read_kwsh_config
         PromptHistory.new(
           cwd: interactive_workspace_root(agent),
           limit: config[:history_limit],
@@ -297,7 +302,7 @@ module Kward
           return
         end
 
-        config = ConfigFiles.read_ekwsh_config
+        config = ConfigFiles.read_kwsh_config
         run_user_interactive_pty_command(
           command,
           shell: config[:shell],
@@ -314,8 +319,9 @@ module Kward
         elsif @prompt.respond_to?(:say)
           @prompt.say(intro_message)
         end
+        origin_tab = active_tab if respond_to?(:active_tab, true)
         result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd) do |sink, completed_result|
-          transcript_output = record_completed_pty_output(sink, completed_result)
+          transcript_output = record_completed_pty_output(sink, completed_result, tab: origin_tab)
           yield(transcript_output, completed_result) if block_given?
         end
         refresh_composer_status
@@ -327,20 +333,29 @@ module Kward
 
       def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, &on_complete)
         runner = InteractivePtyRunner.new
+        origin_tab = active_tab if respond_to?(:active_tab, true)
         with_interactive_terminal_handoff do |input, sink|
+          tab_action_handler = terminal_handoff_tab_action_handler
+          on_detach = if origin_tab
+            -> { BufferedPtyOutputSink.new(max_capture_bytes: Kward::CLI::Tabs::TRANSIENT_SHELL_OUTPUT_LIMIT) }
+          end
           result = if shell.respond_to?(:run_interactive)
-            shell.run_interactive(command, input: input, sink: sink)
+            shell.run_interactive(command, input: input, sink: sink, tab_action_handler: tab_action_handler, on_detach: on_detach)
           else
-            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink)
+            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink, tab_action_handler: tab_action_handler, on_detach: on_detach)
+          end
+          if result&.background
+            register_background_tab_run(origin_tab, result.background, &on_complete)
+          else
+            on_complete.call(sink, result) if on_complete
           end
-          on_complete.call(sink, result) if on_complete
           result
         end
       end
 
       def with_interactive_terminal_handoff
         if @prompt.respond_to?(:with_inline_terminal_handoff)
-          @prompt.with_inline_terminal_handoff do |input, output, transition|
+          with_tab_keybinding_handoff(:with_inline_terminal_handoff) do |input, output, transition|
             sink = AdaptivePtyOutputSink.new(
               output: output,
               on_exclusive: transition,
@@ -349,7 +364,7 @@ module Kward
             yield(input, sink)
           end
         elsif @prompt.respond_to?(:with_terminal_handoff)
-          @prompt.with_terminal_handoff do |input, output|
+          with_tab_keybinding_handoff(:with_terminal_handoff) do |input, output|
             sink = PassthroughPtyOutputSink.new(
               output: output,
               max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
@@ -365,7 +380,31 @@ module Kward
         end
       end
 
-      def record_completed_pty_output(sink, result)
+      def with_tab_keybinding_handoff(method_name)
+        method = @prompt.method(method_name)
+        supports_option = method.parameters.any? do |type, name|
+          type == :keyrest || (type == :key || type == :keyreq) && name == :preserve_tab_keybindings
+        end
+        if supports_option
+          @prompt.public_send(method_name, preserve_tab_keybindings: true) { |*args| yield(*args) }
+        else
+          @prompt.public_send(method_name) { |*args| yield(*args) }
+        end
+      end
+
+      def terminal_handoff_tab_action_handler
+        return unless @prompt.respond_to?(:filter_terminal_handoff_input)
+        return unless respond_to?(:handle_tab_action, true)
+
+        lambda do |chunk|
+          filtered = @prompt.filter_terminal_handoff_input(chunk)
+          action = filtered[:tab_action]
+          handle_tab_action(action, @session_store) if action
+          filtered
+        end
+      end
+
+      def record_completed_pty_output(sink, result, tab: nil)
         classified_output = sink.respond_to?(:transcript_safe?)
         return if classified_output && !sink.transcript_safe?
 
@@ -382,8 +421,8 @@ module Kward
         )
         return unless transcript_output
 
-        record_tab_transient_shell_output(transcript_output, render: false)
-        if @prompt.respond_to?(:record_transient_terminal_output)
+        record_tab_transient_shell_output(transcript_output, render: false, tab: tab)
+        if @prompt.respond_to?(:record_transient_terminal_output) && (!tab || tab == active_tab)
           @prompt.record_transient_terminal_output(transcript_output, render: false)
         end
         transcript_output
@@ -422,14 +461,14 @@ module Kward
         end
       end
 
-      def run_ekwsh_loop(shell, tab: nil, history: nil, shell_agent: nil)
+      def run_kwsh_loop(shell, tab: nil, history: nil, shell_agent: nil)
         shell_agent ||= shell_prompt_agent_for(tab.agent, tab: tab) if tab&.agent
-        with_ekwsh_history(history) do
-          run_ekwsh_loop_with_history(shell, tab: tab, shell_agent: shell_agent)
+        with_kwsh_history(history) do
+          run_kwsh_loop_with_history(shell, tab: tab, shell_agent: shell_agent)
         end
       end
 
-      def run_ekwsh_loop_with_history(shell, tab: nil, shell_agent: nil)
+      def run_kwsh_loop_with_history(shell, tab: nil, shell_agent: nil)
         pending_shell_inputs = []
         loop do
           if @prompt.respond_to?(:editing_file?) && @prompt.editing_file?
@@ -440,7 +479,7 @@ module Kward
             end
           end
 
-          input = pending_shell_inputs.shift || ask_ekwsh(shell)
+          input = pending_shell_inputs.shift || ask_kwsh(shell)
           if input.is_a?(Hash) && input[:tab_action]
             (@pending_inputs ||= []).unshift(input)
             return :tab_action
@@ -452,7 +491,7 @@ module Kward
             next
           end
 
-          result = run_ekwsh_command(shell, input)
+          result = run_kwsh_command(shell, input)
           if result.clear
             clear_active_tab_transient_shell_output
             @prompt.clear_transcript if @prompt.respond_to?(:clear_transcript)
@@ -463,37 +502,39 @@ module Kward
           return :tab_action if pending_tab_action?
 
           if result.open_editor_path
-            editor_result = open_ekwsh_editor(result.open_editor_path, shell)
+            editor_result = open_kwsh_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)
+            pty_result = run_kwsh_interactive_pty_command(shell, result)
+            return :tab_action if pty_result&.tab_action
+
             next
           end
           if result.exit_shell
-            close_ekwsh_session(shell)
+            close_kwsh_session(shell)
             tab.shell = nil if tab
             tab.shell_agent = nil if tab
             runtime_output("Shell exited.")
             return :exited
           end
         end
-        close_ekwsh_session(shell)
+        close_kwsh_session(shell)
         tab.shell = nil if tab
         tab.shell_agent = nil if tab
         runtime_output("Shell exited.")
         :exited
       end
 
-      def close_ekwsh_session(shell)
+      def close_kwsh_session(shell)
         shell.close if shell.respond_to?(:close)
       rescue StandardError
         nil
       end
 
-      def with_ekwsh_history(history)
+      def with_kwsh_history(history)
         if history && @prompt.respond_to?(:with_prompt_history)
           @prompt.with_prompt_history(history) { yield }
         else
@@ -501,7 +542,7 @@ module Kward
         end
       end
 
-      def open_ekwsh_editor(path, shell)
+      def open_kwsh_editor(path, shell)
         unless @prompt.respond_to?(:edit_file)
           runtime_output("Integrated editor is unavailable in this prompt.")
           return false
@@ -516,7 +557,7 @@ module Kward
         result
       end
 
-      def ask_ekwsh(shell)
+      def ask_kwsh(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) }
@@ -525,7 +566,7 @@ module Kward
         end
       end
 
-      def run_ekwsh_interactive_pty_command(shell, result)
+      def run_kwsh_interactive_pty_command(shell, result)
         shell_target = shell.respond_to?(:run_interactive) ? shell : shell.command_shell
         run_user_interactive_pty_command(
           result.interactive_command,
@@ -541,12 +582,12 @@ module Kward
         end
       end
 
-      def run_ekwsh_command(shell, input)
+      def run_kwsh_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)
+          run_streaming_kwsh_command(shell, input)
         elsif @prompt.respond_to?(:write_transcript_delta)
           shell.run(input) { |chunk| @prompt.write_transcript_delta(chunk) }
         else
@@ -556,45 +597,67 @@ module Kward
         @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
       end
 
-      def run_streaming_ekwsh_command(shell, input)
+      def run_streaming_kwsh_command(shell, input)
         cancellation = Cancellation.new
         chunks = Queue.new
         queued_inputs = []
+        origin_tab = active_tab if respond_to?(:active_tab, true)
+        detached_sink = nil
         result = nil
         error = nil
         worker = Thread.new do
-          result = shell.run(input, cancellation: cancellation) { |chunk| chunks << chunk }
+          result = shell.run(input, cancellation: cancellation) do |chunk|
+            if detached_sink
+              detached_sink.write(chunk)
+            else
+              chunks << chunk
+            end
+          end
         rescue StandardError => e
           error = e
         end
         worker.report_on_exception = false
 
         while worker.alive?
-          drain_ekwsh_chunks(chunks)
+          drain_kwsh_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)
+            if origin_tab
+              detached_sink = BufferedPtyOutputSink.new(max_capture_bytes: Kward::CLI::Tabs::TRANSIENT_SHELL_OUTPUT_LIMIT)
+              background = DetachedRun.new(sink: detached_sink, canceler: -> { cancellation.cancel! }) do
+                worker.join
+                raise error if error
+
+                result
+              end
+              register_background_tab_run(origin_tab, background) do |_sink, completed_result|
+                record_tab_transient_shell_output(completed_result.output, render: false, tab: origin_tab)
+                @prompt.say(completed_result.output) if origin_tab == active_tab && completed_result.output.to_s != ""
+              end
+              return Kwsh::Result.new(output: "", exit_status: 0, streamed: true)
+            end
             cancellation.cancel!
           end
           sleep 0.01
         end
         worker.join
-        drain_ekwsh_chunks(chunks)
+        drain_kwsh_chunks(chunks)
         raise error if error
 
         queued_inputs.reverse_each { |pending_input| (@pending_inputs ||= []).unshift(pending_input) }
         result
       end
 
-      def record_tab_transient_shell_output(text, render: true)
+      def record_tab_transient_shell_output(text, render: true, tab: nil)
         value = text.to_s
         return if value.empty?
 
-        tab = active_tab if respond_to?(:active_tab, true)
+        tab ||= active_tab if respond_to?(:active_tab, true)
         tab&.append_transient_shell_entry(value)
-        if render && @prompt.respond_to?(:record_transient_terminal_output)
+        if render && @prompt.respond_to?(:record_transient_terminal_output) && tab == active_tab
           @prompt.record_transient_terminal_output(value)
         end
       end
@@ -641,7 +704,7 @@ module Kward
         after
       end
 
-      def drain_ekwsh_chunks(chunks)
+      def drain_kwsh_chunks(chunks)
         loop do
           @prompt.write_transcript_delta(chunks.pop(true))
         rescue ThreadError

data/lib/kward/cli/slash_commands.rb

@@ -1,3 +1,5 @@
+require_relative "../scratchpad_languages"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
@@ -48,7 +50,7 @@ module Kward
           open_project_files_browser
           [true, nil]
         when "shell"
-          run_ekwsh(agent)
+          run_kwsh(agent)
           [true, nil]
         when "capture"
           run_captured_shell_command(argument, agent)
@@ -304,11 +306,16 @@ module Kward
       end
 
       def open_scratchpad_command(argument)
-        if @prompt.respond_to?(:scratchpad)
-          @prompt.scratchpad(scratchpad_language_argument(argument))
-        else
-          runtime_output("The scratchpad is only available in the interactive prompt.")
+        unless @prompt.respond_to?(:scratchpad)
+          return runtime_output("The scratchpad is only available in the interactive prompt.")
         end
+
+        value = argument.to_s.strip
+        return runtime_output(ScratchpadLanguages.help_text) if value.casecmp("help").zero?
+
+        @prompt.scratchpad(ScratchpadLanguages.normalize(value))
+      rescue ArgumentError => e
+        runtime_output(e.message)
       end
 
       def queue_editor_prompt_action(result)
@@ -318,15 +325,6 @@ module Kward
         @pending_inputs.unshift(result)
       end
 
-      def scratchpad_language_argument(argument)
-        value = argument.to_s.strip.downcase
-        return :text if value.empty? || value == "text"
-        return :markdown if ["markdown", "md"].include?(value)
-        return :ruby if ["ruby", "rb"].include?(value)
-
-        :text
-      end
-
       def open_project_files_browser
         if @prompt.respond_to?(:open_project_browser)
           @prompt.open_project_browser