kward 0.82.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,15 +192,91 @@ 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
-        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_prompt_agent_for(agent, tab: tab)
+        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)
+        return tab.shell_agent if tab&.shell_agent
+        return nil unless agent.respond_to?(:conversation) && agent.respond_to?(:tool_registry)
+
+        shell_agent = build_shell_prompt_agent(agent)
+        tab.shell_agent = shell_agent if tab
+        shell_agent
+      end
+
+      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: 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
+
+      def run_shell_prompt_turn(input, shell, shell_agent)
+        tab = active_tab if respond_to?(:active_tab, true)
+        transcript_before = prompt_transcript_text
+        instruction = input.to_s.sub(/\A\?\s*/, "").strip
+        if instruction.empty?
+          runtime_output("Shell prompt instruction required after ?")
+          return []
+        end
+        unless shell_agent.respond_to?(:tool_registry)
+          runtime_output("Shell agent is unavailable in this prompt.")
+          return []
+        end
+
+        session = ShellPromptSession.new(shell)
+        registry = shell_agent.tool_registry.for_shell_prompt(session)
+        on_complete = lambda do |successful:, **|
+          next unless successful
+          next unless session.prepared_command
+
+          if @prompt.respond_to?(:prefill_input)
+            @prompt.prefill_input(session.prepared_command)
+          else
+            runtime_output("Prepared shell command:\n#{session.prepared_command}")
+          end
+        end
+        pending_inputs = run_interactive_turn(
+          shell_agent,
+          ShellPrompt.input(instruction, session.context),
+          display_input: "? #{instruction}",
+          tool_registry: registry,
+          busy_label: shell.prompt_label,
+          on_complete: on_complete
+        )
+        @prompt.update_prompt_label(shell.prompt_label) if @prompt.respond_to?(:update_prompt_label)
+        pending_inputs
+      rescue StandardError => e
+        runtime_output("Error: #{e.message}")
+        []
+      ensure
+        record_shell_prompt_transcript(tab, transcript_before)
       end
 
-      def build_ekwsh(agent)
-        config = ConfigFiles.read_ekwsh_config
-        Ekwsh.new(
+      def shell_prompt_input?(input)
+        input.to_s.start_with?("?")
+      end
+
+      def build_kwsh(agent)
+        config = ConfigFiles.read_kwsh_config
+        PersistentShellSession.new(
           cwd: interactive_workspace_root(agent),
           configured_env: config[:env],
           aliases: config[:aliases],
@@ -208,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],
@@ -224,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],
@@ -241,8 +319,10 @@ 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|
-          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
         result
@@ -253,39 +333,78 @@ module Kward
 
       def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, &on_complete)
         runner = InteractivePtyRunner.new
-        run_with_sink = lambda do |input, sink|
-          result = runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink)
-          on_complete.call(sink, result) if on_complete
+        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, tab_action_handler: tab_action_handler, on_detach: on_detach)
+          else
+            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
           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,
               max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
             )
-            run_with_sink.call(input, sink)
+            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
             )
-            run_with_sink.call(input, sink)
+            yield(input, sink)
           end
         else
           sink = PassthroughPtyOutputSink.new(
             output: $stdout,
             max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
           )
-          run_with_sink.call($stdin, sink)
+          yield($stdin, sink)
+        end
+      end
+
+      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)
+      def record_completed_pty_output(sink, result, tab: nil)
         classified_output = sink.respond_to?(:transcript_safe?)
         return if classified_output && !sink.transcript_safe?
 
@@ -302,10 +421,11 @@ 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
       end
 
       def terminal_transcript_output(
@@ -341,13 +461,15 @@ module Kward
         end
       end
 
-      def run_ekwsh_loop(shell, tab: nil, history: nil)
-        with_ekwsh_history(history) do
-          run_ekwsh_loop_with_history(shell, tab: tab)
+      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_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)
+      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?
             editor_result = @prompt.run_editor
@@ -357,14 +479,19 @@ module Kward
             end
           end
 
-          input = 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
           end
           break if input.nil?
 
-          result = run_ekwsh_command(shell, input)
+          if shell_prompt_input?(input)
+            pending_shell_inputs.concat(run_shell_prompt_turn(input, shell, shell_agent))
+            next
+          end
+
+          result = run_kwsh_command(shell, input)
           if result.clear
             clear_active_tab_transient_shell_output
             @prompt.clear_transcript if @prompt.respond_to?(:clear_transcript)
@@ -375,27 +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_kwsh_session(shell)
             tab.shell = nil if tab
+            tab.shell_agent = nil if tab
             runtime_output("Shell exited.")
             return :exited
           end
         end
+        close_kwsh_session(shell)
         tab.shell = nil if tab
+        tab.shell_agent = nil if tab
         runtime_output("Shell exited.")
         :exited
       end
 
-      def with_ekwsh_history(history)
+      def close_kwsh_session(shell)
+        shell.close if shell.respond_to?(:close)
+      rescue StandardError
+        nil
+      end
+
+      def with_kwsh_history(history)
         if history && @prompt.respond_to?(:with_prompt_history)
           @prompt.with_prompt_history(history) { yield }
         else
@@ -403,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
@@ -418,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) }
@@ -427,22 +566,28 @@ 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,
-          shell: shell.command_shell,
+          shell: shell_target,
           env: shell.child_env(interactive: true),
           cwd: shell.cwd,
           intro: result.output
-        )
+        ) do |transcript_output, completed_result|
+          shell.record_interactive_result(
+            output: transcript_output,
+            exit_status: completed_result.exit_status
+          )
+        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
@@ -452,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
@@ -499,7 +666,45 @@ module Kward
         clear_active_tab_transient_shell_entries if respond_to?(:clear_active_tab_transient_shell_entries, true)
       end
 
-      def drain_ekwsh_chunks(chunks)
+      def prompt_transcript_text
+        return nil unless @prompt.respond_to?(:tab_view_snapshot)
+
+        snapshot = @prompt.tab_view_snapshot
+        transcript = snapshot[:transcript_buffer] || snapshot["transcript_buffer"] || snapshot[:transcript] || snapshot["transcript"]
+        transcript = transcript.map(&:to_s).join if transcript.is_a?(Array)
+        transcript.to_s
+      rescue StandardError
+        nil
+      end
+
+      def record_shell_prompt_transcript(tab, transcript_before)
+        return unless tab && !transcript_before.nil?
+
+        transcript_after = prompt_transcript_text
+        return if transcript_after.nil?
+
+        delta = shell_prompt_transcript_delta(transcript_before, transcript_after)
+        tab.append_transient_shell_entry(delta) unless delta.empty?
+      rescue StandardError
+        nil
+      end
+
+      def shell_prompt_transcript_delta(before, after)
+        return "" if before == after
+        return after[before.length..].to_s if after.start_with?(before)
+
+        # The prompt transcript is bounded and may trim while a large agent
+        # response is rendered. Preserve only the part not already retained.
+        overlap = [before.length, after.length].min
+        while overlap.positive?
+          return after[overlap..].to_s if before.end_with?(after[0, overlap])
+
+          overlap -= 1
+        end
+        after
+      end
+
+      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,19 +50,23 @@ 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)
           [true, nil]
         when "scratchpad"
-          open_scratchpad_command(argument)
+          result = open_scratchpad_command(argument)
+          queue_editor_prompt_action(result)
           [true, nil]
         when "pty"
           run_interactive_pty_command(argument, agent)
           [true, nil]
         when "tab"
           [true, handle_tab_command(argument, session_store)]
+        when "worktree"
+          handle_worktree_command(argument)
+          [true, active_tab&.agent]
         when "settings"
           configure_settings(agent.conversation)
           [true, nil]
@@ -300,20 +306,23 @@ 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 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)
+      def queue_editor_prompt_action(result)
+        return unless result.is_a?(Hash) && result[:editor_prompt]
 
-        :text
+        @pending_inputs ||= []
+        @pending_inputs.unshift(result)
       end
 
       def open_project_files_browser