kward 0.67.1 → 0.69.0

data/lib/kward/cli/prompt_interface.rb

@@ -0,0 +1,134 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Adapter methods that connect the CLI coordinator to the terminal prompt interface.
+    module PromptInterfaceSupport
+      private
+
+      def setup_interactive_prompt
+        return unless @stdin.tty?
+        return unless @prompt.is_a?(TTY::Prompt)
+
+        prompt_interface = load_prompt_interface
+        return unless prompt_interface
+
+        banner_enabled = ConfigFiles.banner_enabled?
+        @prompt = prompt_interface.new(
+          slash_commands: slash_command_entries,
+          overlay_settings: ConfigFiles.overlay_settings,
+          footer: prompt_footer_renderer,
+          composer_status: method(:composer_status_text),
+          busy_help: ConfigFiles.composer_busy_help?,
+          attachment_badges: method(:composer_attachment_badges),
+          attachment_parser: method(:composer_attachment_parser),
+          banner_pixels: banner_enabled ? Kward::PromptInterface::BANNER_LOGO_PIXELS : nil,
+          banner_message: banner_enabled ? Kward::PromptInterface::BANNER_MESSAGE : nil
+        )
+        @prompt.start
+      end
+
+      def load_prompt_interface
+        require_relative "../prompt_interface"
+        PromptInterface
+      rescue LoadError => e
+        raise unless missing_tty_tui_load_error?(e)
+
+        nil
+      end
+
+      def missing_tty_tui_load_error?(error)
+        ["tty-cursor", "tty-reader", "tty-screen"].include?(error.path) ||
+          error.message.match?(/cannot load such file -- tty-(cursor|reader|screen)/)
+      end
+
+      def prompt_interface?
+        @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
+      end
+
+      # Writes the visual banner output for the terminal CLI flow.
+      def print_visual_banner
+        @prompt.print_visual_banner if @prompt.respond_to?(:print_visual_banner)
+      end
+
+      def prompt_footer_renderer
+        return nil unless plugin_registry.footer_renderer
+
+        lambda do
+          renderer = plugin_registry.footer_renderer
+          next "" unless renderer
+
+          context = plugin_context(current_footer_conversation, "")
+          renderer.call(context).to_s
+        rescue StandardError => e
+          warn "Warning: Kward plugin footer error: #{e.message}"
+          ""
+        end
+      end
+
+      def composer_status_text
+        conversation = current_footer_conversation
+        provider = conversation.provider || (@client.respond_to?(:current_provider) ? @client.current_provider : "Codex")
+        model = conversation.model || (@client.respond_to?(:current_model) ? @client.current_model : ModelInfo::DEFAULT_OPENAI_MODEL)
+        reasoning = conversation.reasoning_effort || (@client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : ModelInfo::DEFAULT_REASONING_EFFORT)
+        reasoning = "n/a" unless ModelInfo.reasoning_supported?(provider, model) && !reasoning.to_s.empty?
+        text = "#{provider} #{model} · #{reasoning}"
+        parts = []
+        diff = composer_session_diff_text
+        parts << diff if diff
+        usage = composer_context_usage(provider, model)
+        parts << composer_context_percent_text(usage[:percent]) if usage
+        parts << text
+        parts.join(" · ")
+      end
+
+      def composer_session_diff_text
+        return nil if @session_diff.nil? || @session_diff.empty?
+
+        additions = ANSI.colorize("+#{@session_diff.additions}", :green, enabled: @color_enabled)
+        deletions = ANSI.colorize("-#{@session_diff.deletions}", :red, enabled: @color_enabled)
+        "#{additions}|#{deletions}"
+      end
+
+      def composer_context_percent_text(percent)
+        value = percent.round
+        color = if value >= 85
+                  :red
+                elsif value >= 50
+                  :yellow
+                end
+        ANSI.colorize("#{value}%", color, enabled: @color_enabled)
+      end
+
+      def composer_context_window(provider = nil, model = nil)
+        provider ||= current_footer_conversation.provider || (@client.respond_to?(:current_provider) ? @client.current_provider : "Codex")
+        model ||= current_footer_conversation.model || (@client.respond_to?(:current_model) ? @client.current_model : ModelInfo::DEFAULT_OPENAI_MODEL)
+        ModelInfo.context_window(ModelInfo.provider_label(provider), model)
+      end
+
+      def composer_context_usage(provider, model)
+        context_window = composer_context_window(provider, model)
+        context_parts = if @client.respond_to?(:current_context_parts)
+                          @client.current_context_parts(current_footer_conversation.context_messages, footer_tool_schemas)
+                        else
+                          { provider: provider, model: model, messages: current_footer_conversation.context_messages, tools: footer_tool_schemas }
+                        end
+        @context_usage.call(
+          provider: provider,
+          model: model,
+          context_window: context_window,
+          context_parts: context_parts
+        )
+      end
+
+      def footer_tool_schemas
+        @footer_tool_registry&.schemas || []
+      end
+
+      def current_footer_conversation
+        @footer_conversation || Conversation.new(system_message: nil)
+      end
+
+    end
+  end
+end

data/lib/kward/cli/rendering.rb

@@ -0,0 +1,378 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Terminal rendering helpers for streamed assistant/tool output.
+    module Rendering
+      private
+
+      def render_conversation_transcript(conversation)
+        tool_calls_by_id = {}
+        @prompt.say("\n#{colored("Transcript", :gray, :bold)}\n")
+        conversation.messages.each do |message|
+          role = message_role(message)
+          next if role == "system"
+
+          case role
+          when "user"
+            print_user_transcript(
+              CLITranscriptFormatter.user_transcript_input(message),
+              display_input: CLITranscriptFormatter.user_display_text(message),
+              attachment_references: CLITranscriptFormatter.image_references(message),
+              image_parts: CLITranscriptFormatter.image_parts(message)
+            )
+          when "assistant"
+            render_reasoning(message)
+            render_assistant_message(message)
+            message_tool_calls(message).each do |tool_call|
+              tool_calls_by_id[tool_call_id(tool_call)] = tool_call
+            end
+          when "tool"
+            render_tool_message(message, tool_calls_by_id)
+          when "compactionSummary"
+            render_transcript_block("Compaction summary", message_summary(message))
+          else
+            render_transcript_block(role.to_s.capitalize, CLITranscriptFormatter.content_text(message_content(message)))
+          end
+        end
+      end
+
+      def render_reasoning(message)
+        reasoning = CLITranscriptFormatter.reasoning(message)
+        render_transcript_block("Reasoning", reasoning) unless reasoning.empty?
+      end
+
+      def render_assistant_message(message)
+        content = CLITranscriptFormatter.assistant_content_text(message)
+        return if content.empty?
+
+        render_transcript_block("Assistant", content)
+      end
+
+      def render_tool_message(message, tool_calls_by_id)
+        tool_call = tool_calls_by_id[message_tool_call_id(message)] || CLITranscriptFormatter.synthetic_tool_call(message_name(message), message_tool_call_id(message))
+        render_tool_result(tool_call, message_content(message).to_s)
+      end
+
+      def render_tool_result(tool_call, content)
+        summary = limit_tool_output_lines(tool_result_summary(tool_call, content), INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+        if prompt_interface?
+          print_tool_result(tool_call, content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+        else
+          @prompt.say("\n#{colored("Tool>", *tool_label_styles(content))}\n#{summary}\n")
+        end
+      end
+
+      def render_transcript_block(label, content)
+        return if content.to_s.empty?
+
+        rendered = render_markdown_transcript(content)
+        if prompt_interface?
+          print_block_delta(label, rendered)
+          finish_stream_block
+        else
+          @prompt.say("\n#{colored("#{transcript_label(label)}>", *label_styles(label))}\n#{rendered}\n")
+        end
+      end
+
+      def render_markdown_transcript(content)
+        ANSI.markdown(content, enabled: @color_enabled)
+      end
+
+      def render_blocking_turn_event(event, markdown_chunks, tool_line_limit: nil, update_diff: false)
+        case event
+        when Events::ReasoningDelta
+          append_markdown_delta(markdown_chunks, "Reasoning", event.delta)
+          :streamed
+        when Events::AssistantDelta
+          append_markdown_delta(markdown_chunks, "Assistant", event.delta)
+          :assistant_streamed
+        when Events::Retry
+          flush_markdown_deltas(markdown_chunks)
+          print_retry(event)
+          :streamed
+        when Events::ToolCall
+          flush_markdown_deltas(markdown_chunks)
+          :streamed
+        when Events::ToolResult
+          flush_markdown_deltas(markdown_chunks)
+          update_session_diff(event.content, tool_call: event.tool_call) if update_diff
+          print_tool_result(event.tool_call, event.content, line_limit: tool_line_limit)
+          :streamed
+        end
+      end
+
+      def append_markdown_delta(chunks, label, delta)
+        text = delta.to_s
+        return if text.empty?
+
+        if chunks.last&.first == label
+          chunks.last[1] << text
+        else
+          chunks << [label, +text]
+        end
+      end
+
+      def flush_markdown_deltas(chunks, finish: true, streams: nil)
+        wrote = false
+        entries = ordered_markdown_entries(chunks.dup)
+        if finish && streams
+          streamed_labels = entries.map(&:first)
+          entries = ordered_markdown_entries(entries.concat(streams.keys.reject { |label| streamed_labels.include?(label) }.map { |label| [label, ""] }))
+        end
+
+        entries.each do |label, content|
+          next if content.empty? && !(finish && streams&.key?(label))
+
+          rendered = if streams
+            streams[label] ||= ANSI::MarkdownStream.new(enabled: @color_enabled)
+            streams[label].render(content, final: finish)
+          else
+            render_markdown_transcript(content)
+          end
+          streams.delete(label) if finish && streams
+          next if rendered.empty?
+
+          print_block_delta(label, rendered)
+          finish_stream_block if finish
+          wrote = true
+        end
+        chunks.clear
+        wrote
+      end
+
+      def ordered_markdown_entries(entries)
+        labels = entries.map(&:first)
+        return entries unless labels.include?("Reasoning") && labels.include?("Assistant")
+
+        grouped = { "Reasoning" => +"", "Assistant" => +"" }
+        others = []
+        entries.each do |label, content|
+          if grouped.key?(label)
+            grouped[label] << content.to_s
+          else
+            others << [label, content]
+          end
+        end
+
+        [["Reasoning", grouped["Reasoning"]], ["Assistant", grouped["Assistant"]]] + others
+      end
+
+      def message_role(message)
+        MessageAccess.role(message)
+      end
+
+      def message_content(message)
+        MessageAccess.content(message)
+      end
+
+      def message_summary(message)
+        MessageAccess.summary(message) || message_content(message)
+      end
+
+      def message_name(message)
+        MessageAccess.name(message)
+      end
+
+      def message_tool_call_id(message)
+        MessageAccess.tool_call_id(message)
+      end
+
+      def message_tool_calls(message)
+        MessageAccess.tool_calls(message)
+      end
+
+      def tool_call_id(tool_call)
+        tool_call["id"] || tool_call[:id]
+      end
+
+      # 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
+        @prompt.say("\n#{colored("You>", :blue, :bold)} #{visible_input}\n")
+        print_attachment_badges(input, references: attachment_references)
+        print_pasted_images(input, image_parts: image_parts)
+      end
+
+      # Writes the attachment badges output for the terminal CLI flow.
+      def print_attachment_badges(input, references: nil)
+        badges = references ? Array(references).map { |reference| attachment_badge_text(reference) } : composer_attachment_badges(input)
+        return if badges.empty?
+
+        @prompt.say("#{badges.join("\n")}\n")
+      end
+
+      def composer_attachment_badges(input, attachments = [])
+        references = Array(attachments)
+        references = Kward::ImageAttachments.references_from_text(input) if references.empty?
+        references.map { |reference| attachment_badge_text(reference) }
+      end
+
+      def composer_attachment_parser(input)
+        Kward::ImageAttachments.extract_references_from_text(input)
+      end
+
+      def submitted_display_input(input)
+        input.respond_to?(:display_input) ? input.display_input : nil
+      end
+
+      def attachment_badge_text(reference)
+        status = reference[:status] || reference["status"]
+        label = reference[:label] || reference["label"] || "image"
+        if status == :missing || status.to_s == "missing"
+          "[image?] #{label} not found"
+        else
+          media_type = reference[:media_type] || reference["media_type"] || reference[:mimeType] || reference["mimeType"] || "image"
+          size = format_attachment_size(reference[:size_bytes] || reference["size_bytes"] || reference[:sizeBytes] || reference["sizeBytes"])
+          "[image] #{label} · #{media_type}#{size.empty? ? "" : " · #{size}"}"
+        end
+      end
+
+      def format_attachment_size(bytes)
+        value = bytes.to_i
+        return "" unless value.positive?
+        return "#{value} B" if value < 1024
+
+        units = %w[KB MB GB]
+        size = value.to_f / 1024
+        unit = units.shift
+        while size >= 1024 && units.any?
+          size /= 1024
+          unit = units.shift
+        end
+        formatted = size >= 10 ? size.round.to_s : format("%.1f", size).sub(/\.0\z/, "")
+        "#{formatted} #{unit}"
+      end
+
+      # Writes the pasted images output for the terminal CLI flow.
+      def print_pasted_images(input, image_parts: nil)
+        parts = image_parts || Kward::ImageAttachments.image_parts_from_text(input)
+        parts.each do |part|
+          sequence = Kward::ImageAttachments.terminal_image_sequence(part)
+          next unless sequence
+
+          if @prompt.respond_to?(:say_visual)
+            @prompt.say_visual(sequence)
+          else
+            @prompt.say(sequence)
+          end
+        end
+      end
+
+      # Writes the block delta output for the terminal CLI flow.
+      def print_block_delta(label, delta)
+        if prompt_interface?
+          @prompt.start_stream_block(label)
+          @prompt.write_delta(delta)
+        else
+          start_stream_block(label)
+          print delta
+          $stdout.flush
+        end
+      end
+
+      # Writes the retry output for the terminal CLI flow.
+      def print_retry(event)
+        message = retry_message(event)
+        if prompt_interface?
+          if @prompt.respond_to?(:write_stream_block)
+            @prompt.write_stream_block("Retry", "#{message}\n", finish: true)
+          else
+            @prompt.start_stream_block("Retry")
+            @prompt.write_delta("#{message}\n")
+            @prompt.finish_stream_block
+          end
+        else
+          start_stream_block("Retry")
+          puts message
+          $stdout.flush
+          @stream_block = nil
+        end
+      end
+
+      def retry_message(event)
+        RetryMessage.format(event)
+      end
+
+      # Writes the tool result output for the terminal CLI flow.
+      def print_tool_result(tool_call, content, line_limit: nil)
+        summary = tool_result_summary(tool_call, content)
+        summary = limit_tool_output_lines(summary, line_limit) if line_limit
+        if prompt_interface?
+          summary = summary.end_with?("\n") ? summary : "#{summary}\n"
+          if @prompt.respond_to?(:write_stream_block)
+            @prompt.write_stream_block("Tool", summary, finish: true)
+          else
+            @prompt.start_stream_block("Tool")
+            @prompt.write_delta(summary)
+            @prompt.finish_stream_block
+          end
+        else
+          start_stream_block(tool_stream_label(content))
+          print summary
+          puts unless summary.end_with?("\n")
+          $stdout.flush
+          @stream_block = nil
+        end
+      end
+
+      def start_stream_block(label)
+        return if @stream_block == label
+
+        puts if @stream_block
+        puts "\n#{colored("#{transcript_label(label)}>", *label_styles(label))}"
+        @stream_block = label
+      end
+
+      def finish_stream_block
+        if prompt_interface?
+          @prompt.finish_stream_block
+        else
+          puts if @stream_block
+          @stream_block = nil
+        end
+      end
+
+      def colored(text, *styles)
+        ANSI.colorize(text, *styles, enabled: @color_enabled)
+      end
+
+      def transcript_label(label)
+        case label
+        when "Assistant"
+          assistant_prompt_name
+        when "Tool failed"
+          "Tool"
+        else
+          label
+        end
+      end
+
+      def label_styles(label)
+        case label
+        when "Reasoning", "Compaction summary"
+          [:gray, :bold]
+        when "Assistant", "Kward"
+          [:green, :bold]
+        when "Tool", "Tool output"
+          [:cyan, :bold]
+        when "Tool failed"
+          [:red, :bold]
+        when "Retry"
+          [:yellow, :bold]
+        else
+          [:gray, :bold]
+        end
+      end
+
+      def tool_stream_label(content)
+        tool_result_failed?(content) ? "Tool failed" : "Tool"
+      end
+
+      def tool_label_styles(content)
+        label_styles(tool_stream_label(content))
+      end
+
+    end
+  end
+end

data/lib/kward/cli/runtime_helpers.rb

@@ -0,0 +1,170 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Shared runtime construction helpers for CLI conversations, workspaces, plugins, and sessions.
+    module RuntimeHelpers
+      private
+
+      def new_conversation(workspace_root: current_workspace_root)
+        Conversation.new(workspace_root: workspace_root, provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort, plugin_registry: plugin_registry)
+      end
+
+      def update_assistant_prompt(conversation)
+        @assistant_prompt = assistant_prompt_label(conversation)
+        @prompt.update_assistant_label(assistant_prompt_name) if @prompt.respond_to?(:update_assistant_label)
+        @assistant_prompt
+      end
+
+      def assistant_prompt_label(conversation)
+        label = ConfigFiles.active_persona_label(workspace_root: conversation.workspace_root, model: conversation.model)
+        "#{label || "Assistant"}>"
+      rescue StandardError
+        "Assistant>"
+      end
+
+      def assistant_prompt_name
+        assistant_output_prompt.delete_suffix(">")
+      end
+
+      def assistant_output_prompt
+        @assistant_prompt || "Assistant>"
+      end
+
+      def runtime_output_prompt
+        "Runtime>"
+      end
+
+      def runtime_output(text)
+        content = text.to_s.chomp
+        label = colored(runtime_output_prompt, :gray, :bold)
+        separator = content.include?("\n") ? "\n" : " "
+        @prompt.say("\n#{label}#{separator}#{content}\n")
+      end
+
+      def build_interactive_agent(conversation)
+        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)
+        @footer_conversation = conversation
+        @footer_tool_registry = tool_registry
+        Agent.new(
+          client: @client,
+          tool_registry: tool_registry,
+          conversation: conversation
+        )
+      end
+
+      def handle_interactive_shell_command(input, agent)
+        command = input.to_s.sub(/\A!\s*/, "")
+        if command.strip.empty?
+          runtime_output("Shell command is required after !")
+          return true
+        end
+
+        run_busy_local_command_and_requeue(activity: "running") do
+          result = configured_workspace(root: interactive_workspace_root(agent)).run_shell_command(command)
+          @prompt.say("\n#{colored("Shell>", :cyan, :bold)} #{command}\n#{result}\n")
+        end
+        true
+      end
+
+      def shell_command_input?(input)
+        input.to_s.start_with?("!")
+      end
+
+      def configured_workspace(root: current_workspace_root)
+        Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
+      end
+
+      def workspace_guardrails_enabled?
+        ConfigFiles.workspace_guardrails_enabled?(safely_read_config.to_h)
+      end
+
+      def interactive_workspace_root(agent)
+        conversation = agent.conversation if agent.respond_to?(:conversation)
+        return conversation.workspace_root if conversation&.respond_to?(:workspace_root)
+
+        current_workspace_root
+      end
+
+      def run_busy_local_command(activity: "loading")
+        return yield unless prompt_interface?
+
+        queued_inputs = []
+        result = nil
+        error = nil
+        @prompt.begin_busy_input("You>", activity: activity) if @prompt.respond_to?(:begin_busy_input)
+
+        worker = Thread.new do
+          result = yield
+        rescue StandardError => e
+          error = e
+        end
+
+        while worker.alive?
+          collect_queued_input(queued_inputs)
+          sleep 0.02
+        end
+        worker.join
+        drain_queued_input(queued_inputs)
+        raise error if error
+
+        [result, queued_inputs]
+      ensure
+        @prompt.finish_busy_input if prompt_interface? && @prompt.respond_to?(:finish_busy_input)
+      end
+
+      def run_busy_local_command_and_requeue(activity: "loading")
+        return yield unless prompt_interface?
+
+        result, queued_inputs = run_busy_local_command(activity: activity) { yield }
+        queued_inputs.reverse_each { |pending_input| @pending_inputs.unshift(pending_input) }
+        result
+      end
+
+      def current_workspace_root
+        return @active_session.cwd.to_s unless @active_session&.cwd.to_s.empty?
+        return @working_directory if @working_directory
+
+        Dir.pwd
+      end
+
+      def current_model_provider
+        @client.respond_to?(:current_provider) ? @client.current_provider : "Codex"
+      end
+
+      def current_model_id
+        @client.respond_to?(:current_model) ? @client.current_model : ModelInfo::DEFAULT_OPENAI_MODEL
+      end
+
+      def current_reasoning_effort
+        @client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : ModelInfo::DEFAULT_REASONING_EFFORT
+      end
+
+      def reload_client_config
+        @client.reload_config if @client.respond_to?(:reload_config)
+      end
+
+      def refresh_conversation_runtime(conversation)
+        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)
+        update_assistant_prompt(conversation)
+      end
+
+      def auto_name_active_session(input)
+        return unless @active_session
+        return unless @active_session.name.to_s.strip.empty?
+
+        name = default_session_name(input)
+        @active_session.rename(name) unless name.empty?
+      end
+
+      def default_session_name(input)
+        input.to_s.gsub(/\s+/, " ").strip.slice(0, 120).to_s
+      end
+
+    end
+  end
+end