kward 0.82.0 → 0.84.0

data/lib/kward/cli/interactive_turn.rb

@@ -6,9 +6,70 @@ module Kward
     module InteractiveTurn
       private
 
-      def run_interactive_turn(agent, input, display_input: nil)
-        prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
-        return run_blocking_interactive_turn(agent, input, display_input: display_input) unless prompt_interface?
+      def run_editor_prompt_turn(action, agent)
+        unless agent.respond_to?(:tool_registry) && agent.tool_registry.respond_to?(:for_editor_prompt)
+          runtime_output("Editor prompts are unavailable in this tab.")
+          return []
+        end
+        unless @prompt.respond_to?(:editor_prompt_context)
+          runtime_output("Editor prompts are unavailable in this prompt.")
+          return []
+        end
+
+        context = @prompt.editor_prompt_context
+        unless context
+          runtime_output("Open a Modern or Vibe editor buffer before prompting the agent.")
+          return []
+        end
+
+        unless @prompt.suspend_editor_for_agent
+          runtime_output("The editor is busy.")
+          return []
+        end
+
+        session = EditorPromptSession.new(context)
+        registry = agent.tool_registry.for_editor_prompt(session)
+        editor_agent = build_editor_prompt_agent(agent, context, registry)
+        instruction = action[:instruction] || action["instruction"]
+        run_interactive_turn(
+          editor_agent,
+          EditorPrompt.input(instruction, context),
+          tool_registry: registry,
+          editor_prompt_session: session,
+          suppress_transcript: true
+        )
+      rescue StandardError => e
+        @prompt.resume_editor_for_agent(status: "Agent request failed") if @prompt.respond_to?(:resume_editor_for_agent)
+        runtime_output("Error: #{e.message}")
+        []
+      end
+
+      def build_editor_prompt_agent(active_agent, context, registry)
+        active_conversation = active_agent.conversation
+        config = safely_read_config.to_h
+        configured_provider = ConfigFiles.editor_agent_provider(config)
+        provider = configured_provider || active_conversation.provider || current_model_provider
+        model = ConfigFiles.editor_agent_model(config) || (configured_provider ? nil : active_conversation.model || current_model_id)
+        reasoning = ConfigFiles.editor_agent_reasoning_effort(config) || (configured_provider ? nil : active_conversation.reasoning_effort || current_reasoning_effort)
+        conversation = Conversation.new(
+          system_message: EditorPrompt.system_message,
+          workspace_root: context[:workspace_root] || active_conversation.workspace_root,
+          provider: provider,
+          model: model,
+          reasoning_effort: reasoning
+        )
+        Agent.new(
+          client: @client,
+          tool_registry: registry,
+          conversation: conversation,
+          strict_provider: !configured_provider.nil?,
+          warning_sink: ConfigFiles.warning_sink
+        )
+      end
+
+      def run_interactive_turn(agent, input, display_input: nil, tool_registry: nil, editor_prompt_session: nil, suppress_transcript: false, busy_label: "You>", on_complete: nil)
+        prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation) && !suppress_transcript
+        return run_blocking_interactive_turn(agent, input, display_input: display_input, tool_registry: tool_registry, suppress_transcript: suppress_transcript, on_complete: on_complete) unless prompt_interface?
 
         queued_inputs = []
         cancellation = Cancellation.new
@@ -17,19 +78,21 @@ module Kward
         event_queue = Queue.new
         stream_state = {
           streamed: false,
+          assistant_arrived: false,
           last_flush: monotonic_now,
           stream_block_open: false,
           markdown_streams: {},
+          tool_elapsed_ms: {},
           defer_assistant_streaming: defer_assistant_streaming?(agent)
         }
         markdown_chunks = []
         answer = nil
         error = nil
-        @prompt.begin_busy_input("You>") if @prompt.respond_to?(:begin_busy_input)
-        print_user_transcript(input, display_input: display_input)
+        @prompt.begin_busy_input(busy_label) if @prompt.respond_to?(:begin_busy_input)
+        print_user_transcript(input, display_input: display_input) unless suppress_transcript
 
         worker = Thread.new do
-          options = agent_display_options(display_input)
+          options = agent_display_options(display_input, tool_registry: tool_registry)
           options[:cancellation] = cancellation
           options[:steering] = steering if steering
           answer = agent.ask(input, **options) do |event|
@@ -52,7 +115,7 @@ module Kward
             cancellation.cancel!
             worker.raise(Cancellation::CancelledError, "cancelled") if worker.alive?
           end
-          if busy_replacement_agent?
+          if busy_replacement_agent? || suppress_transcript
             discard_interactive_events(event_queue, markdown_chunks, stream_state)
           else
             drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
@@ -64,19 +127,49 @@ module Kward
           error ||= e
         end
         drain_busy_input(queued_inputs, nil) unless cancelled
-        if busy_replacement_agent?
+        if busy_replacement_agent? || suppress_transcript
           discard_interactive_events(event_queue, markdown_chunks, stream_state, force: true)
         else
-          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
+          drain_remaining_interactive_events(event_queue, markdown_chunks, stream_state, agent)
         end
+        completed = !cancelled && !busy_replacement_agent? && !error
+        on_complete&.call(successful: completed, cancelled: cancelled, error: error, answer: answer)
         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 || 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
+        @prompt.commit_editor_prompt(editor_prompt_session) if editor_prompt_session && completed
+        @prompt.say("\n#{colored(transcript_marker("Assistant"), :activity, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || cancelled || busy_replacement_agent? || stream_state[:streamed] || answer.to_s.empty?
+        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript && queued_inputs.empty? && !cancelled
         queued_inputs
       ensure
         @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+        if @prompt.respond_to?(:show_completion) && !busy_replacement_agent?
+          completion = if cancelled
+            :cancelled
+          elsif error
+            :failed
+          elsif completed
+            :success
+          end
+          @prompt.show_completion(completion) if completion
+        end
+        if editor_prompt_session && @prompt.respond_to?(:resume_editor_for_agent)
+          status = if cancelled
+            "Agent request cancelled"
+          elsif error
+            "Agent request failed"
+          elsif editor_prompt_session && !editor_prompt_session.changed? && !answer.to_s.strip.empty?
+            editor_prompt_answer_status(answer)
+          end
+          @prompt.resume_editor_for_agent(status: status)
+        end
+      end
+
+      def editor_prompt_answer_status(answer)
+        text = answer.to_s.gsub(/\s+/, " ").strip
+        text = text[0, 120].to_s
+        text += "…" if answer.to_s.gsub(/\s+/, " ").strip.length > text.length
+        "Agent: #{text}"
       end
 
       def drain_interactive_events(event_queue, markdown_chunks, stream_state, agent = nil, force: false)
@@ -95,6 +188,14 @@ module Kward
         flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: force)
       end
 
+      def drain_remaining_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+        until event_queue.empty?
+          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+          sleep STREAM_RENDER_INTERVAL unless event_queue.empty?
+        end
+        drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
+      end
+
       def discard_interactive_events(event_queue, markdown_chunks, stream_state, force: false)
         drained = 0
         loop do
@@ -114,12 +215,19 @@ module Kward
         case event
         when Events::ReasoningDelta
           stream_state[:streamed] = true
+          update_busy_activity("reasoning")
           append_markdown_delta(markdown_chunks, "Reasoning", event.delta)
         when Events::ReasoningBoundary
           stream_state[:streamed] = true
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          update_busy_activity("thinking")
         when Events::AssistantDelta
           stream_state[:streamed] = true
+          unless stream_state[:assistant_arrived]
+            @prompt.show_response_arrival if @prompt.respond_to?(:show_response_arrival)
+            stream_state[:assistant_arrived] = true
+          end
+          update_busy_activity("responding")
           append_markdown_delta(markdown_chunks, "Assistant", event.delta)
         when Events::Steering
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
@@ -129,18 +237,30 @@ module Kward
         when Events::Retry
           stream_state[:streamed] = true
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          update_busy_activity("retrying")
           print_retry(event)
         when Events::ToolCall
           stream_state[:streamed] = true
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          update_busy_activity(tool_activity(event.tool_call))
+        when Events::ToolUpdate
+          key = tool_call_id(event.tool_call) || event.tool_call.object_id
+          stream_state[:tool_elapsed_ms][key] = event.elapsed_ms
         when Events::ToolResult
           stream_state[:streamed] = true
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
           update_session_diff(event.content, tool_call: event.tool_call)
-          print_tool_result(event.tool_call, event.content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+          key = tool_call_id(event.tool_call) || event.tool_call.object_id
+          elapsed_ms = stream_state[:tool_elapsed_ms].delete(key)
+          print_tool_result(event.tool_call, event.content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT, elapsed_ms: elapsed_ms)
+          update_busy_activity("thinking")
         end
       end
 
+      def update_busy_activity(activity)
+        @prompt.update_busy_activity(activity) if @prompt.respond_to?(:update_busy_activity)
+      end
+
       def flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: false)
         if force
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
@@ -261,21 +381,24 @@ module Kward
         ModelInfo.reasoning_supported?(current_model_provider, model)
       end
 
-      def run_blocking_interactive_turn(agent, input, display_input: nil)
+      def run_blocking_interactive_turn(agent, input, display_input: nil, tool_registry: nil, suppress_transcript: false, on_complete: nil)
         streamed = false
         markdown_chunks = []
-        answer = agent.ask(input, **agent_display_options(display_input)) do |event|
-          streamed = true if render_blocking_turn_event(event, markdown_chunks, tool_line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+        answer = agent.ask(input, **agent_display_options(display_input, tool_registry: tool_registry)) do |event|
+          streamed = true if !suppress_transcript && render_blocking_turn_event(event, markdown_chunks, tool_line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
         end
         flush_markdown_deltas(markdown_chunks) if streamed
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless 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)
+        @prompt.say("\n#{colored(transcript_marker("Assistant"), :activity, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || streamed || answer.to_s.empty?
+        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        on_complete&.call(successful: true, cancelled: false, error: nil, answer: answer)
         []
       end
 
-      def agent_display_options(display_input)
-        display_input.nil? ? {} : { display_input: display_input }
+      def agent_display_options(display_input, tool_registry: nil)
+        options = display_input.nil? ? {} : { display_input: display_input }
+        options[:tool_registry] = tool_registry if tool_registry
+        options
       end
 
     end

data/lib/kward/cli/project_skills_commands.rb

@@ -7,20 +7,20 @@ module Kward
         argument = Array(arguments).join(" ").strip.downcase
         _workspace_root, candidates, coordinator = project_skill_trust_coordinator
         if candidates.empty? && argument != "untrust"
-          @prompt.say("No project skills found in the current workspace.")
+          project_skills_cli_output("No project skills found in the current workspace.")
           return
         end
 
         case argument
         when "", "status"
           lines = candidates.empty? ? ["No project skills found in the current workspace."] : candidates.map { |candidate| "#{relative_workspace_path(candidate.path)}: #{coordinator.decision(candidate) || "needs review"}" }
-          @prompt.say(lines.join("\n"))
+          project_skills_cli_output(lines.join("\n"))
         when "trust"
           coordinator.record!(candidates, "allow")
-          @prompt.say("Project skills trusted for the current skill snapshots.")
+          project_skills_cli_output("Project skills trusted for the current skill snapshots.")
         when "untrust"
           coordinator.remove_workspace!
-          @prompt.say("Project skill trust removed for this workspace.")
+          project_skills_cli_output("Project skill trust removed for this workspace.")
         when "review"
           review_project_skills(candidates)
         else
@@ -43,6 +43,10 @@ module Kward
 
       private
 
+      def project_skills_cli_output(message)
+        @prompt.say("#{colored("Project skills", :green, :bold)}\n\n#{message}")
+      end
+
       def project_skill_trust_coordinator
         workspace_root = current_workspace_root
         candidates = ConfigFiles.project_skill_candidates(workspace_root: workspace_root)

data/lib/kward/cli/prompt_interface.rb

@@ -45,6 +45,7 @@ module Kward
           editor_line_numbers_source: -> { ConfigFiles.editor_line_numbers },
           diff_view: ConfigFiles.diff_view,
           diff_view_source: -> { ConfigFiles.diff_view },
+          editor_runners_source: -> { ConfigFiles.editor_runners },
           redraw_handler: method(:redraw_interactive_prompt)
         )
         if @prompt.method(:start).parameters.any? { |kind, name| [:key, :keyreq].include?(kind) && name == :render }
@@ -99,6 +100,13 @@ module Kward
         @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
       end
 
+      def open_editor_for_agent(path, base_dir:, allow_new:)
+        return false unless prompt_interface?
+        return false unless @prompt.respond_to?(:edit_file)
+
+        @prompt.edit_file(path, base_dir: base_dir, allow_new: allow_new)
+      end
+
       def emit_warning(message)
         sink = ConfigFiles.warning_sink
         sink ? sink.call(message) : warn(message)
@@ -129,6 +137,7 @@ module Kward
         [
           startup_status_line(refresh_update_check: refresh_update_check),
           *startup_update_notice_lines,
+          *startup_authentication_notice_lines,
           "",
           startup_info_line("Workspace", startup_workspace_label),
           startup_info_line("Branch", startup_branch_value),
@@ -198,6 +207,24 @@ module Kward
         @startup_update_notice = @startup_update_check.notice(refresh: refresh)
       end
 
+      def startup_authentication_notice_lines
+        return [] unless startup_authentication_required?
+
+        [
+          ANSI.colorize("  No model provider is connected.", :yellow, enabled: @color_enabled),
+          "  Run /login to sign in, or /model to configure a local server."
+        ]
+      end
+
+      def startup_authentication_required?
+        return false unless @client.is_a?(Client)
+        return false if @client.current_provider == "Local"
+
+        auth_credentials.none? { |credential| credential.fetch(:configured) }
+      rescue StandardError
+        false
+      end
+
       def startup_info_line(label, value)
         "#{ANSI.colorize(label.ljust(12), :gray, enabled: @color_enabled)}#{ANSI.colorize(value, :cyan, enabled: @color_enabled)}"
       end

data/lib/kward/cli/rendering.rb

@@ -223,7 +223,7 @@ module Kward
       # Writes the user transcript output for the terminal CLI flow.
       def print_user_transcript(input, display_input: nil, attachment_references: nil, image_parts: nil)
         visible_input = display_input.nil? ? input : display_input
-        write_prompt_transcript("\n#{colored("You>", :blue, :bold)} #{visible_input}\n")
+        write_prompt_transcript("\n#{colored("❯ You>", :blue, :bold)} #{visible_input}\n")
         print_attachment_badges(input, references: attachment_references)
         print_pasted_images(input, image_parts: image_parts)
       end
@@ -347,8 +347,9 @@ module Kward
       end
 
       # Writes the tool result output for the terminal CLI flow.
-      def print_tool_result(tool_call, content, line_limit: nil)
+      def print_tool_result(tool_call, content, line_limit: nil, elapsed_ms: nil)
         summary = tool_result_summary(tool_call, content)
+        summary = tool_summary_with_duration(summary, elapsed_ms)
         summary = limit_tool_output_lines(summary, line_limit) if line_limit
         display_summary = tool_summary_display_text(summary)
         if prompt_interface?
@@ -380,7 +381,7 @@ module Kward
         return if @stream_block == label
 
         puts if @stream_block
-        print "\n#{colored("#{transcript_label(label)}>", *label_styles(label))} "
+        print "\n#{colored(transcript_marker(label), *label_styles(label))} "
         @stream_block = label
       end
 
@@ -408,20 +409,25 @@ module Kward
         end
       end
 
+      def transcript_marker(label)
+        marker = "#{transcript_label(label)}>"
+        label == "Assistant" ? "✦ #{marker}" : marker
+      end
+
       def label_styles(label)
         case label
         when "Reasoning", "Compaction summary"
-          [:gray, :bold]
+          [:metadata, :bold]
         when "Assistant", "Kward"
-          [:green, :bold]
+          [:activity, :bold]
         when "Tool", "Tool output"
-          [:cyan, :bold]
+          [:tool, :bold]
         when "Tool failed"
-          [:red, :bold]
+          [:failure, :bold]
         when "Retry"
-          [:yellow, :bold]
+          [:caution, :bold]
         else
-          [:gray, :bold]
+          [:metadata, :bold]
         end
       end