kward 0.71.0 → 0.73.0

data/lib/kward/cli/git.rb

@@ -0,0 +1,150 @@
+require "open3"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Interactive Git status and commit helpers.
+    module GitCommands
+      private
+
+      def handle_git_command(agent)
+        unless @prompt.respond_to?(:git_commit_message)
+          runtime_output("/git is available in the interactive overlay only.")
+          return
+        end
+
+        root = interactive_workspace_root(agent)
+        git_root = git_repository_root(root)
+        if git_root.empty?
+          runtime_output("Not a Git repository: #{root}")
+          return
+        end
+
+        status = git_status_lines(git_root)
+        message = @prompt.git_commit_message(status) do |action|
+          result = handle_git_prompt_action(git_root, status, action)
+          status = result.is_a?(Hash) && result.key?(:status_lines) ? result[:status_lines] : result
+          result
+        end
+        return if message.nil?
+
+        result = run_busy_local_command_and_requeue(activity: "committing") do
+          git_commit(git_root, message)
+        end
+        print_git_commit_result(result)
+      end
+
+      def git_repository_root(root)
+        output, status = Open3.capture2e("git", "rev-parse", "--show-toplevel", chdir: root.to_s)
+        return "" unless status.success?
+
+        output.lines.first.to_s.strip
+      rescue StandardError
+        ""
+      end
+
+      def git_status_lines(root)
+        output, status = Open3.capture2e("git", "status", "--short", "--untracked-files=normal", chdir: root.to_s)
+        return ["Unable to read Git status: #{output.strip}"] unless status.success?
+
+        output.lines.map(&:chomp)
+      rescue StandardError => e
+        ["Unable to read Git status: #{e.message}"]
+      end
+
+      def handle_git_prompt_action(root, current_status, action)
+        case action[:action]
+        when :toggle_stage
+          toggle_git_stage(root, current_status[action[:index].to_i])
+          git_status_lines(root)
+        when :open_diff
+          status_line = current_status[action[:index].to_i]
+          { status_lines: git_status_lines(root), diff: git_diff_view(root, status_line) }
+        else
+          git_status_lines(root)
+        end
+      end
+
+      def git_diff_view(root, status_line)
+        entry = parse_git_status_line(status_line)
+        return { path: "Git diff", content: "Unable to read Git status entry.\n" } if entry.nil?
+
+        output = entry[:untracked] ? git_untracked_file_diff(root, entry[:path]) : git_tracked_file_diff(root, entry[:path])
+        { path: entry[:path], content: output.empty? ? "No diff for #{entry[:path]}\n" : output }
+      end
+
+      def git_tracked_file_diff(root, path)
+        output, status = Open3.capture2e("git", "diff", "HEAD", "--", path, chdir: root.to_s)
+        status.success? ? output : "Unable to read diff for #{path}:\n#{output}"
+      rescue StandardError => e
+        "Unable to read diff for #{path}: #{e.message}\n"
+      end
+
+      def git_untracked_file_diff(root, path)
+        full_path = File.expand_path(path, root.to_s)
+        content = File.file?(full_path) ? File.read(full_path) : ""
+        lines = ["diff --git a/#{path} b/#{path}", "new file mode 100644", "--- /dev/null", "+++ b/#{path}", "@@ -0,0 +1,#{content.lines.length} @@"]
+        lines.concat(content.lines(chomp: true).map { |line| "+#{line}" })
+        lines << "\" if !content.empty? && !content.end_with?("\n")
+        lines.join("\n") + "\n"
+      rescue StandardError => e
+        "Unable to read diff for #{path}: #{e.message}\n"
+      end
+
+      def toggle_git_stage(root, status_line)
+        entry = parse_git_status_line(status_line)
+        return if entry.nil?
+
+        command = entry[:staged] ? ["restore", "--staged", "--", entry[:path]] : ["add", "--", entry[:path]]
+        Open3.capture2e("git", *command, chdir: root.to_s)
+      rescue StandardError
+        nil
+      end
+
+      def parse_git_status_line(line)
+        text = line.to_s
+        return nil if text.length < 4
+
+        status = text[0, 2]
+        path = text[3..].to_s
+        path = path.split(" -> ", 2).last if status.include?("R") || status.include?("C")
+        return nil if path.empty?
+
+        { path: path, staged: status[0] != " " && status[0] != "?", untracked: status == "??" }
+      end
+
+      def git_commit(root, message)
+        return git_commit_staged(root, message) if git_staged_changes?(root)
+
+        add_output, add_status = Open3.capture2e("git", "add", "--all", chdir: root.to_s)
+        return { success: false, output: add_output } unless add_status.success?
+
+        git_commit_staged(root, message)
+      rescue StandardError => e
+        { success: false, output: e.message }
+      end
+
+      def git_staged_changes?(root)
+        _output, status = Open3.capture2e("git", "diff", "--cached", "--quiet", chdir: root.to_s)
+        !status.success?
+      rescue StandardError
+        false
+      end
+
+      def git_commit_staged(root, message)
+        commit_output, commit_status = Open3.capture2e("git", "commit", "-m", message.to_s, chdir: root.to_s)
+        { success: commit_status.success?, output: commit_output }
+      rescue StandardError => e
+        { success: false, output: e.message }
+      end
+
+      def print_git_commit_result(result)
+        output = result[:output].to_s.strip
+        output = result[:success] ? "Commit created." : "Git commit failed." if output.empty?
+        status = result[:success] ? "Git commit succeeded" : "Git commit failed"
+        runtime_output("#{status}\n#{output}")
+      end
+    end
+  end
+end

data/lib/kward/cli/interactive_turn.rb

@@ -7,6 +7,7 @@ module Kward
       private
 
       def run_interactive_turn(agent, input, display_input: nil)
+        stop_live_worker_view if respond_to?(:stop_live_worker_view, true)
         prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
         print_user_transcript(input, display_input: display_input) if prompt_interface?
         return run_blocking_interactive_turn(agent, input, display_input: display_input) unless prompt_interface?
@@ -42,7 +43,7 @@ module Kward
 
         while worker.alive?
           begin
-            poll_result = collect_busy_input(queued_inputs, steering)
+            poll_result = collect_busy_input(queued_inputs, steering, agent)
             sleep 0.01
           rescue Interrupt
             poll_result = PromptInterface::CANCEL_INPUT
@@ -52,7 +53,11 @@ module Kward
             cancellation.cancel!
             worker.raise(Cancellation::CancelledError, "cancelled") if worker.alive?
           end
-          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+          if busy_replacement_agent?
+            discard_interactive_events(event_queue, markdown_chunks, stream_state)
+          else
+            drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+          end
         end
         begin
           worker.join
@@ -60,10 +65,14 @@ module Kward
           error ||= e
         end
         drain_busy_input(queued_inputs, nil) unless cancelled
-        drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
-        raise error if error && !error.is_a?(Cancellation::CancelledError)
+        if busy_replacement_agent?
+          discard_interactive_events(event_queue, markdown_chunks, stream_state, force: true)
+        else
+          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
+        end
+        raise error if error && !error.is_a?(Cancellation::CancelledError) && !busy_replacement_agent?
 
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless cancelled || stream_state[:streamed] || answer.to_s.empty?
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless cancelled || busy_replacement_agent? || stream_state[:streamed] || answer.to_s.empty?
         persist_memory_state(agent.conversation) if agent.respond_to?(:conversation)
         auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && queued_inputs.empty? && !cancelled
         queued_inputs
@@ -87,6 +96,21 @@ module Kward
         flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: force)
       end
 
+      def discard_interactive_events(event_queue, markdown_chunks, stream_state, force: false)
+        drained = 0
+        loop do
+          break if !force && drained >= INTERACTIVE_EVENT_DRAIN_LIMIT
+
+          event_queue.pop(true)
+          drained += 1
+        rescue ThreadError
+          break
+        end
+        markdown_chunks.clear
+        finish_stream_block if stream_state[:stream_block_open]
+        stream_state[:stream_block_open] = false
+      end
+
       def handle_interactive_event(event, markdown_chunks, stream_state)
         case event
         when Events::ReasoningDelta
@@ -154,13 +178,18 @@ module Kward
         collect_busy_input(queued_inputs, nil)
       end
 
-      def collect_busy_input(queued_inputs, steering)
+      def collect_busy_input(queued_inputs, steering, agent = nil)
         return nil if @prompt.respond_to?(:modal_active?) && @prompt.modal_active?
 
         poll_result = @prompt.poll_input
         case poll_result
         when String
-          if steering && !poll_result.strip.empty?
+          return poll_result if handle_busy_worker_input(poll_result, agent, queued_inputs)
+
+          if slash_command_input?(poll_result)
+            queued_inputs << poll_result
+            @prompt.set_queued_count(queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
+          elsif steering && !poll_result.strip.empty?
             begin
               steering.submit(poll_result)
               @prompt.set_steered_count(1) if @prompt.respond_to?(:set_steered_count)
@@ -183,16 +212,51 @@ module Kward
         drain_busy_input(queued_inputs, nil)
       end
 
-      def drain_busy_input(queued_inputs, steering)
+      def drain_busy_input(queued_inputs, steering, agent = nil)
         deadline = Time.now + 0.15
         loop do
-          poll_result = collect_busy_input(queued_inputs, steering)
+          poll_result = collect_busy_input(queued_inputs, steering, agent)
           break if Time.now > deadline && poll_result.nil?
 
           sleep 0.01
         end
       end
 
+      def slash_command_input?(input)
+        input.to_s.strip.start_with?("/")
+      end
+
+      def handle_busy_worker_input(input, agent, queued_inputs)
+        return false unless agent
+
+        command = input.to_s.strip
+        return false unless command == "/workers" || command.start_with?("/workers ")
+
+        _handled, replacement_agent = handle_local_slash_command(command, agent, @session_store)
+        @busy_replacement_agent = replacement_agent if replacement_agent?(replacement_agent)
+        restore_busy_input_prompt
+        true
+      rescue StandardError => e
+        runtime_output("Error: #{e.message}")
+        restore_busy_input_prompt
+        true
+      end
+
+      def replacement_agent?(object)
+        object.respond_to?(:conversation) && object.respond_to?(:ask)
+      end
+
+      def busy_replacement_agent?
+        replacement_agent?(@busy_replacement_agent)
+      end
+
+      def restore_busy_input_prompt
+        return unless @prompt.respond_to?(:begin_busy_input)
+        return if @prompt.respond_to?(:modal_active?) && @prompt.modal_active?
+
+        @prompt.begin_busy_input("You>")
+      end
+
       def steering_supported?
         @client.respond_to?(:supports_in_flight_steer?) && @client.supports_in_flight_steer?
       end

data/lib/kward/cli/plugins.rb

@@ -7,7 +7,7 @@ module Kward
       private
 
       def prompt_templates
-        @prompt_templates ||= ConfigFiles.prompt_templates(reserved_commands: BUILTIN_SLASH_COMMAND_NAMES)
+        @prompt_templates ||= ConfigFiles.prompt_templates(reserved_commands: builtin_slash_command_names)
       end
 
       def plugin_registry
@@ -22,6 +22,14 @@ module Kward
         plugin_registry.command_for(command)
       end
 
+      def interactive_commands
+        plugin_registry.interactive_commands
+      end
+
+      def interactive_command_for(command)
+        plugin_registry.interactive_command_for(command)
+      end
+
       def reload_plugins(conversation)
         @plugin_registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
         conversation.plugin_registry = @plugin_registry if conversation.respond_to?(:plugin_registry=)
@@ -30,7 +38,34 @@ module Kward
       end
 
       def reserved_slash_command_names
-        BUILTIN_SLASH_COMMAND_NAMES + prompt_templates.map(&:command)
+        builtin_slash_command_names + prompt_templates.map(&:command)
+      end
+
+      def run_interactive_command(name, argument, agent)
+        command = interactive_command_for(name)
+        return [false, nil] unless command
+        return [false, nil] unless prompt_interface? && @prompt.respond_to?(:start_interactive)
+
+        context = plugin_context(agent.conversation, argument)
+        controller = @prompt.start_interactive(title: "/#{name}", rows: command.rows, fps: command.fps)
+        command.handler.call(controller, context)
+        run_interactive_loop
+        [true, nil]
+      rescue StandardError => e
+        @prompt.finish_interactive if @prompt.respond_to?(:finish_interactive)
+        runtime_output("Interactive command /#{name} error: #{e.message}")
+        [true, nil]
+      end
+
+      def run_interactive_loop
+        loop do
+          result = @prompt.poll_input
+          if result == :interactive_exited || @prompt.interactive_exited?
+            @prompt.finish_interactive
+            break
+          end
+          sleep 0.01
+        end
       end
 
       def slash_command_entries
@@ -42,15 +77,30 @@ module Kward
           }
         end
         plugin_entries = plugin_commands.map(&:entry)
-        BUILTIN_SLASH_COMMANDS + prompt_entries + plugin_entries
+        interactive_entries = interactive_commands.map(&:entry)
+        builtin_slash_commands + prompt_entries + plugin_entries + interactive_entries
       end
 
       def prompt_template_for(command)
         prompt_templates.find { |template| template.command == command }
       end
 
+      def builtin_slash_commands
+        return BUILTIN_SLASH_COMMANDS if experimental_workers_enabled?
+
+        BUILTIN_SLASH_COMMANDS.reject { |command| %w[workers queue].include?(command[:name]) }
+      end
+
+      def builtin_slash_command_names
+        builtin_slash_commands.map { |command| command[:name] }
+      end
+
+      def experimental_workers_enabled?
+        @experimental_workers == true
+      end
+
       def expand_prompt_template(input)
-        PromptCommands.expand(input, templates: prompt_templates, reserved_commands: BUILTIN_SLASH_COMMAND_NAMES)
+        PromptCommands.expand(input, templates: prompt_templates, reserved_commands: builtin_slash_command_names)
       end
 
       def run_plugin_command(name, argument, agent)

data/lib/kward/cli/prompt_interface.rb

@@ -23,7 +23,21 @@ module Kward
           busy_help: ConfigFiles.composer_busy_help?,
           attachment_badges: method(:composer_attachment_badges),
           attachment_parser: method(:composer_attachment_parser),
-          banner_message: Kward::PromptInterface::BANNER_MESSAGE
+          banner_message: Kward::PromptInterface::BANNER_MESSAGE,
+          tab_keybindings: ConfigFiles.composer_tab_keybindings,
+          prompt_history: PromptHistory.new(cwd: current_workspace_root),
+          editor_mode: ConfigFiles.editor_mode,
+          editor_mode_source: -> { ConfigFiles.editor_mode },
+          editor_auto_indent: ConfigFiles.editor_auto_indent?,
+          editor_auto_indent_source: -> { ConfigFiles.editor_auto_indent? },
+          editor_auto_close_pairs: ConfigFiles.editor_auto_close_pairs?,
+          editor_auto_close_pairs_source: -> { ConfigFiles.editor_auto_close_pairs? },
+          editor_soft_wrap: ConfigFiles.editor_soft_wrap?,
+          editor_soft_wrap_source: -> { ConfigFiles.editor_soft_wrap? },
+          editor_bar_cursor: ConfigFiles.editor_bar_cursor?,
+          editor_bar_cursor_source: -> { ConfigFiles.editor_bar_cursor? },
+          editor_line_numbers: ConfigFiles.editor_line_numbers,
+          editor_line_numbers_source: -> { ConfigFiles.editor_line_numbers }
         )
         if @prompt.method(:start).parameters.any? { |kind, name| [:key, :keyreq].include?(kind) && name == :render }
           @prompt.start(render: false)
@@ -149,6 +163,8 @@ module Kward
         reasoning = "n/a" unless ModelInfo.reasoning_supported?(provider, model) && !reasoning.to_s.empty?
         text = "#{provider} #{model} · #{reasoning}"
         parts = []
+        git = composer_git_branch_text
+        parts << git if git
         diff = composer_session_diff_text
         parts << diff if diff
         usage = composer_context_usage(provider, model)
@@ -165,6 +181,21 @@ module Kward
         "#{additions}|#{deletions}"
       end
 
+      def composer_git_branch_text
+        git_root = startup_git_root(current_workspace_root)
+        return nil if git_root.to_s.empty?
+
+        branch = startup_git_output(%w[git branch --show-current], root: git_root)
+        branch = startup_git_output(%w[git rev-parse --short HEAD], root: git_root) if branch.empty?
+        branch = "unknown" if branch.empty?
+        color = composer_git_dirty?(git_root) ? :yellow : nil
+        ANSI.colorize(branch, color, enabled: @color_enabled)
+      end
+
+      def composer_git_dirty?(git_root)
+        !startup_git_output(%w[git status --porcelain --untracked-files=normal], root: git_root).empty?
+      end
+
       def composer_context_percent_text(percent)
         value = percent.round
         color = if value >= 85

data/lib/kward/cli/rendering.rb

@@ -318,7 +318,10 @@ module Kward
       end
 
       def tool_summary_display_text(summary)
-        summary.to_s.sub("\n", "\n\n")
+        text = summary.to_s
+        return text if text.start_with?("read_skill:\n")
+
+        text.sub("\n", "\n\n")
       end
 
       def start_stream_block(label)