kward 0.83.0 → 0.85.0

data/lib/kward/prompt_interface/editor/runner.rb

@@ -0,0 +1,362 @@
+require_relative "scratchpad_runner"
+require_relative "runner_state"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Coordinates execution and output viewing for editor buffers.
+  class PromptInterface
+    module EditorRunner
+      private
+
+      def editor_runner_config
+        config = @editor_runners_source.respond_to?(:call) ? @editor_runners_source.call : {}
+        config.is_a?(Hash) ? config : {}
+      end
+
+      def editor_runner_output_visible?
+        @editor_runner_output_visible && @editor_runner_state
+      end
+
+      def editor_runner_running?
+        @editor_runner_state&.running?
+      end
+
+      def run_editor_buffer(source: nil, language: nil, source_path: nil, output_visible: true, completion: nil)
+        return false unless @editor_state
+        return false if @editor_state.readonly?
+        if editor_runner_running?
+          @editor_runner_output_visible = true
+          @editor_state.status = "Runner already active · Ctrl+C cancel"
+          return false
+        end
+
+        language ||= @editor_state.language || editor_syntax_language
+        unless ScratchpadLanguages.runnable?(language)
+          @editor_state.status = "No runner available for #{language || "text"}"
+          return false
+        end
+
+        source = source.nil? ? @editor_state.buffer.dup : source.to_s
+        source_path ||= @editor_state.path
+        workspace_root = prompt_workspace_root
+        state = EditorRunnerState.new(language: language, source: source)
+        @editor_runner_state = state
+        @editor_runner_completion = completion
+        @editor_runner_output_visible = output_visible
+        clear_editor_runner_selection
+        @editor_state.status = "Running #{language} · Ctrl+C cancel"
+        Thread.new do
+          Thread.current.report_on_exception = false
+          result = ScratchpadRunner.run(
+            language,
+            source,
+            cancelled: state.method(:cancel_requested?),
+            cwd: workspace_root,
+            source_path: source_path,
+            runner_config: editor_runner_config
+          )
+          finish_editor_runner(state, result)
+        rescue StandardError => e
+          fail_editor_runner(state, e)
+        end
+        true
+      end
+
+      def finish_editor_runner(state, result)
+        @mutex.synchronize do
+          return unless @editor_runner_state.equal?(state) && @editor_state
+
+          state.complete(result)
+          completion = @editor_runner_completion
+          @editor_runner_completion = nil
+          @editor_runner_output_visible = false if completion
+          completion ? completion.call(result, nil) : @editor_state.status = editor_runner_result_status(result)
+          render_prompt_locked if @started && @asking
+        end
+      end
+
+      def fail_editor_runner(state, error)
+        @mutex.synchronize do
+          return unless @editor_runner_state.equal?(state) && @editor_state
+
+          state.fail(error)
+          completion = @editor_runner_completion
+          @editor_runner_completion = nil
+          @editor_runner_output_visible = false if completion
+          if completion
+            completion.call(nil, error)
+          else
+            @editor_state.status = "Run failed: #{error.message}"
+          end
+          render_prompt_locked if @started && @asking
+        end
+      end
+
+      def editor_runner_result_status(result)
+        return "Canceled · Esc close · Ctrl+R rerun" if result.cancelled
+
+        "Exit #{result.exit_status} · #{format_runner_duration(result.duration)} · Esc close · Ctrl+R rerun"
+      end
+
+      def format_runner_duration(duration)
+        format("%.2fs", duration.to_f)
+      end
+
+      def cancel_editor_runner
+        return false unless editor_runner_running?
+
+        @editor_runner_state.cancel
+        @editor_state.status = "Canceling #{@editor_runner_state.language} · please wait"
+        true
+      end
+
+      def close_editor_runner_output
+        @editor_runner_output_visible = false
+        clear_editor_runner_selection
+        true
+      end
+
+      def handle_editor_runner_output_key(key)
+        mouse_result = handle_editor_runner_mouse_key(key)
+        return mouse_result unless mouse_result == false
+        return true if handle_bundled_key(key) { |token| handle_editor_runner_output_key(token) }
+
+        if (sequence = parse_csi_u_key(key))
+          queue_pending_keys(sequence[:remaining]) if sequence[:remaining] && !sequence[:remaining].empty?
+          if sequence[:code] == 121 && !ctrl_modifier?(sequence[:modifier]) && @editor_state&.vibe? && editor_runner_selection_active?
+            return copy_editor_runner_selection
+          end
+          normalized_code = ctrl_code(sequence[:code])
+          if (ctrl_modifier?(sequence[:modifier]) || super_modifier?(sequence[:modifier])) && normalized_code == 99
+            return copy_editor_runner_selection if editor_runner_selection_active?
+            return cancel_editor_runner if ctrl_modifier?(sequence[:modifier]) && editor_runner_running?
+          end
+          if ctrl_modifier?(sequence[:modifier])
+            return run_editor_buffer if normalized_code == 114
+            if normalized_code == 113
+              close_editor_runner_output
+              return quit_editor
+            end
+          end
+          return close_editor_runner_output if sequence[:code] == 27
+        end
+
+        key_name = key_name_for(key)
+        case key_name
+        when :up
+          scroll_editor_runner_output(-1)
+        when :down
+          scroll_editor_runner_output(1)
+        when :pageup
+          scroll_editor_runner_output(-editor_runner_output_page_size)
+        when :pagedown
+          scroll_editor_runner_output(editor_runner_output_page_size)
+        when :ctrl_q
+          close_editor_runner_output
+          quit_editor
+        when :ctrl_r
+          run_editor_buffer
+        when :ctrl_c
+          if editor_runner_selection_active?
+            copy_editor_runner_selection
+          else
+            editor_runner_running? ? cancel_editor_runner : close_editor_runner_output
+          end
+        else
+          case key
+          when "\e", "q", "Q"
+            close_editor_runner_output
+          when "y"
+            copy_editor_runner_selection if @editor_state&.vibe? && editor_runner_selection_active?
+          when TerminalKeys::CTRL_Q
+            close_editor_runner_output
+            quit_editor
+          when TerminalKeys::CTRL_R
+            run_editor_buffer
+          when TerminalKeys::CTRL_C
+            if editor_runner_selection_active?
+              copy_editor_runner_selection
+            else
+              editor_runner_running? ? cancel_editor_runner : close_editor_runner_output
+            end
+          end
+        end
+        true
+      end
+
+      def handle_editor_runner_mouse_key(key)
+        event = parse_sgr_mouse_event(key)
+        return false unless event
+
+        queue_pending_keys(event[:remaining]) unless event[:remaining].empty?
+        case event[:code]
+        when 64
+          scroll_editor_runner_output(-1)
+        when 65
+          scroll_editor_runner_output(1)
+        else
+          if event[:drag]
+            update_editor_runner_selection(editor_runner_position_for_mouse_event(event))
+          elsif event[:button].zero?
+            event[:release] ? finish_editor_runner_selection : begin_editor_runner_selection(event)
+          end
+        end
+        true
+      end
+
+      def begin_editor_runner_selection(event)
+        position = editor_runner_position_for_mouse_event(event)
+        return true unless position
+
+        click_count = editor_runner_mouse_click_count(event)
+        case click_count
+        when 3..Float::INFINITY
+          @editor_runner_selection_anchor = [position[0], 0]
+          @editor_runner_selection_cursor = [position[0], editor_runner_line(position[0]).length]
+        when 2
+          range = editor_runner_word_range_at(position)
+          if range
+            @editor_runner_selection_anchor = [position[0], range[0]]
+            @editor_runner_selection_cursor = [position[0], range[1]]
+          else
+            @editor_runner_selection_anchor = position
+            @editor_runner_selection_cursor = position
+          end
+        else
+          @editor_runner_selection_anchor = position
+          @editor_runner_selection_cursor = position
+        end
+        @editor_runner_mouse_dragging = true
+        true
+      end
+
+      def update_editor_runner_selection(position)
+        return true unless @editor_runner_mouse_dragging && position
+
+        @editor_runner_selection_cursor = position
+        true
+      end
+
+      def finish_editor_runner_selection
+        @editor_runner_mouse_dragging = false
+        true
+      end
+
+      def editor_runner_mouse_click_count(event)
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        count = if @editor_runner_last_click && now - @editor_runner_last_click[:time] <= 0.5 &&
+                   (@editor_runner_last_click[:column] - event[:column]).abs <= 1 &&
+                   (@editor_runner_last_click[:row] - event[:row]).abs <= 1
+                  @editor_runner_last_click[:count] + 1
+                else
+                  1
+                end
+        @editor_runner_last_click = { time: now, column: event[:column], row: event[:row], count: count }
+        count
+      end
+
+      def editor_runner_position_for_mouse_event(event)
+        row_offset = event[:row] - editor_runner_output_content_top_row
+        return nil if row_offset.negative? || row_offset >= editor_runner_output_visible_count
+
+        line_index = @editor_runner_state.scroll_row + row_offset
+        line = editor_runner_line(line_index)
+        return nil unless line
+
+        column = [[event[:column] - 3, 0].max, line.length].min
+        [line_index, column]
+      end
+
+      def editor_runner_output_content_top_row
+        height = screen_height
+        source_count, = editor_split_visible_counts(height: height, width: screen_width)
+        composer_top_row(height) + source_count + 3
+      end
+
+      def editor_runner_line(line_index)
+        lines = editor_runner_output_lines([screen_width - 4, 1].max)
+        line = lines[line_index]
+        line && ANSI.strip(line)
+      end
+
+      def editor_runner_selection_active?
+        @editor_runner_selection_anchor && @editor_runner_selection_cursor &&
+          @editor_runner_selection_anchor != @editor_runner_selection_cursor
+      end
+
+      def clear_editor_runner_selection
+        @editor_runner_selection_anchor = nil
+        @editor_runner_selection_cursor = nil
+        @editor_runner_mouse_dragging = false
+        @editor_runner_last_click = nil
+      end
+
+      def editor_runner_selection_bounds
+        return nil unless editor_runner_selection_active?
+
+        [@editor_runner_selection_anchor, @editor_runner_selection_cursor].minmax_by { |position| position }
+      end
+
+      def editor_runner_selection_range_for(line_index, line_length)
+        bounds = editor_runner_selection_bounds
+        return nil unless bounds
+
+        first, last = bounds
+        return nil if line_index < first[0] || line_index > last[0]
+
+        start_column = line_index == first[0] ? first[1] : 0
+        end_column = line_index == last[0] ? last[1] : line_length
+        [start_column, end_column] if start_column < end_column
+      end
+
+      def editor_runner_word_range_at(position)
+        line = editor_runner_line(position[0]).to_s
+        return nil if line.empty? || TextBoundary.word_separator?(line[[position[1], line.length - 1].min])
+
+        index = [position[1], line.length - 1].min
+        start_column = index
+        start_column -= 1 while start_column.positive? && !TextBoundary.word_separator?(line[start_column - 1])
+        end_column = index + 1
+        end_column += 1 while end_column < line.length && !TextBoundary.word_separator?(line[end_column])
+        [start_column, end_column]
+      end
+
+      def editor_runner_selected_text
+        bounds = editor_runner_selection_bounds
+        return "" unless bounds
+
+        first, last = bounds
+        lines = (first[0]..last[0]).map { |line_index| editor_runner_line(line_index).to_s }
+        if lines.length == 1
+          lines[0] = lines[0][first[1]...last[1]] || ""
+        else
+          lines[0] = lines[0][first[1]..] || ""
+          lines[-1] = lines[-1][...last[1]] || ""
+        end
+        lines.join("\n")
+      end
+
+      def copy_editor_runner_selection
+        text = editor_runner_selected_text
+        return false if text.empty?
+
+        print_output_locked(TerminalSequences.osc52(text))
+        flush_output_locked if @output_io.respond_to?(:flush)
+        clear_editor_runner_selection
+        @editor_state.status = "Copied selection"
+        true
+      end
+
+      def scroll_editor_runner_output(delta)
+        return false unless @editor_runner_state
+
+        @editor_runner_state.scroll_by(delta, maximum: editor_runner_output_scroll_max)
+        true
+      end
+
+      def editor_runner_output_page_size
+        [editor_runner_output_visible_count, 1].max
+      end
+    end
+  end
+end

data/lib/kward/prompt_interface/editor/runner_state.rb

@@ -0,0 +1,78 @@
+require "digest"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Ephemeral state for the output of an editor runner.
+  class PromptInterface
+    class EditorRunnerState
+      attr_reader :language, :source_digest
+
+      def initialize(language:, source:)
+        @language = language.to_sym
+        @source_digest = Digest::SHA256.hexdigest(source.to_s)
+        @mutex = Mutex.new
+        @running = true
+        @cancel_requested = false
+        @result = nil
+        @error = nil
+        @scroll_row = 0
+      end
+
+      def running?
+        @mutex.synchronize { @running }
+      end
+
+      def cancel_requested?
+        @mutex.synchronize { @cancel_requested }
+      end
+
+      def cancel
+        @mutex.synchronize { @cancel_requested = true }
+      end
+
+      def complete(result)
+        @mutex.synchronize do
+          @result = result
+          @running = false
+        end
+      end
+
+      def fail(error)
+        @mutex.synchronize do
+          @error = error
+          @running = false
+        end
+      end
+
+      def result
+        @mutex.synchronize { @result }
+      end
+
+      def error
+        @mutex.synchronize { @error }
+      end
+
+      def output_text
+        @mutex.synchronize do
+          return @error.message.to_s if @error
+
+          @result&.output.to_s
+        end
+      end
+
+      def scroll_row
+        @mutex.synchronize { @scroll_row }
+      end
+
+      def set_scroll_row(row, maximum:)
+        @mutex.synchronize do
+          @scroll_row = [[row.to_i, 0].max, maximum.to_i].min
+        end
+      end
+
+      def scroll_by(delta, maximum:)
+        set_scroll_row(scroll_row + delta.to_i, maximum: maximum)
+      end
+    end
+  end
+end

data/lib/kward/prompt_interface/editor/scratchpad_languages.rb

@@ -0,0 +1,74 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Names, aliases, and display paths accepted by the scratchpad command.
+  module ScratchpadLanguages
+    LANGUAGES = {
+      text: { aliases: %w[text txt], display_path: "scratchpad.txt" },
+      ruby: { aliases: %w[ruby rb], display_path: "scratchpad.rb", runner: :ruby },
+      erb: { aliases: %w[erb], display_path: "scratchpad.erb" },
+      crystal: { aliases: %w[crystal cr], display_path: "scratchpad.cr", runner: :crystal },
+      elixir: { aliases: %w[elixir ex exs], display_path: "scratchpad.ex", runner: :elixir },
+      julia: { aliases: %w[julia jl], display_path: "scratchpad.jl", runner: :julia },
+      javascript: { aliases: %w[javascript js jsx mjs cjs], display_path: "scratchpad.js", runner: :node },
+      typescript: { aliases: %w[typescript ts tsx], display_path: "scratchpad.ts", runner: :node },
+      json: { aliases: %w[json], display_path: "scratchpad.json" },
+      markdown: { aliases: %w[markdown md], display_path: "scratchpad.md" },
+      yaml: { aliases: %w[yaml yml], display_path: "scratchpad.yml" },
+      shell: { aliases: %w[shell sh bash zsh fish], display_path: "scratchpad.sh", runner: :shell },
+      makefile: { aliases: %w[makefile make mk], display_path: "scratchpad.mk" },
+      html: { aliases: %w[html htm], display_path: "scratchpad.html" },
+      css: { aliases: %w[css], display_path: "scratchpad.css" },
+      scss: { aliases: %w[scss], display_path: "scratchpad.scss" },
+      python: { aliases: %w[python py pyw], display_path: "scratchpad.py", runner: :python },
+      go: { aliases: %w[go], display_path: "scratchpad.go", runner: :go },
+      rust: { aliases: %w[rust rs], display_path: "scratchpad.rs" },
+      java: { aliases: %w[java], display_path: "scratchpad.java" },
+      csharp: { aliases: %w[csharp cs c#], display_path: "scratchpad.cs" },
+      c: { aliases: %w[c], display_path: "scratchpad.c" },
+      cpp: { aliases: %w[cpp cc cxx hpp hh hxx c++], display_path: "scratchpad.cpp" },
+      swift: { aliases: %w[swift], display_path: "scratchpad.swift", runner: :swift },
+      kotlin: { aliases: %w[kotlin kt kts], display_path: "scratchpad.kt" },
+      lua: { aliases: %w[lua], display_path: "scratchpad.lua", runner: :lua },
+      sql: { aliases: %w[sql], display_path: "scratchpad.sql" }
+    }.freeze
+
+    ALIASES = LANGUAGES.each_with_object({}) do |(language, definition), aliases|
+      ([language.to_s] + definition.fetch(:aliases)).each do |name|
+        aliases[name] = language
+      end
+    end.freeze
+
+    module_function
+
+    def normalize(language)
+      value = language.to_s.strip.downcase
+      return :text if value.empty?
+
+      ALIASES.fetch(value) do
+        raise ArgumentError, "Unknown scratchpad language #{language.inspect}. Use /scratchpad help for supported languages."
+      end
+    end
+
+    def display_path(language)
+      LANGUAGES.fetch(normalize(language)).fetch(:display_path)
+    end
+
+    def runner(language)
+      LANGUAGES.fetch(normalize(language))[:runner]
+    end
+
+    def runnable?(language)
+      !runner(language).nil?
+    end
+
+    def help_text
+      lines = ["Supported scratchpad languages:"]
+      LANGUAGES.each do |language, definition|
+        aliases = definition.fetch(:aliases).reject { |name| name == language.to_s }
+        suffix = aliases.empty? ? "" : " (#{aliases.join(", ")})"
+        lines << "  #{language}#{suffix}"
+      end
+      lines.join("\n")
+    end
+  end
+end

data/lib/kward/prompt_interface/editor/scratchpad_runner.rb

@@ -0,0 +1,182 @@
+require "open3"
+require "rbconfig"
+require "tempfile"
+require_relative "scratchpad_languages"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Executes editor buffers and returns captured runner output.
+  module ScratchpadRunner
+    OUTPUT_READ_SIZE = 16 * 1024
+    MAX_OUTPUT_BYTES = 1_000_000
+    POLL_INTERVAL = 0.05
+
+    DEFAULT_BINARIES = {
+      ruby: -> { RbConfig.ruby },
+      node: "node",
+      python: -> { windows_host? ? "python" : "python3" },
+      shell: -> { File.executable?("/bin/sh") ? "/bin/sh" : "sh" },
+      lua: "lua",
+      julia: "julia",
+      elixir: "elixir",
+      crystal: "crystal",
+      swift: "swift",
+      go: "go"
+    }.freeze
+    RUNNER_ARGUMENTS = {
+      crystal: ["run"],
+      go: ["run"]
+    }.freeze
+
+    Result = Struct.new(:language, :output, :exit_status, :duration, :command, :cancelled, :truncated, keyword_init: true)
+
+    module_function
+
+    def run(language, content, cancelled: nil, cwd: Dir.pwd, source_path: nil, runner_config: {})
+      language = ScratchpadLanguages.normalize(language)
+      runner = ScratchpadLanguages.runner(language)
+      raise ArgumentError, "Scratchpad language #{language.inspect} is not runnable" unless runner
+
+      cwd = File.expand_path(cwd.to_s.empty? ? Dir.pwd : cwd)
+      binary = configured_binary(runner, runner_config, cwd)
+      arguments = RUNNER_ARGUMENTS.fetch(runner, [])
+      default_display_path = ScratchpadLanguages.display_path(language)
+      display_path = source_path.to_s.empty? ? default_display_path : File.basename(source_path.to_s)
+      extension = File.extname(display_path)
+      extension = File.extname(default_display_path) if extension.empty?
+      started_at = monotonic_now
+      output, status, was_cancelled, truncated = capture_source(
+        content,
+        extension: extension,
+        source_path: source_path,
+        cwd: cwd,
+        command: [binary, *arguments],
+        cancelled: cancelled
+      )
+      Result.new(
+        language: language,
+        output: output,
+        exit_status: was_cancelled ? 130 : status.exitstatus,
+        duration: monotonic_now - started_at,
+        command: [binary, *arguments, "<#{display_path}>"],
+        cancelled: was_cancelled,
+        truncated: truncated
+      )
+    rescue Errno::ENOENT
+      raise ArgumentError, "Editor runner #{runner.inspect} binary #{binary.inspect} was not found"
+    rescue Errno::EACCES
+      raise ArgumentError, "Editor runner #{runner.inspect} binary #{binary.inspect} is not executable"
+    end
+
+    def capture_source(content, extension:, source_path:, cwd:, command:, cancelled: nil)
+      Tempfile.create(["kward-scratchpad", extension], dir: temporary_directory(cwd, source_path)) do |file|
+        file.write(content.to_s)
+        file.flush
+        capture_process([*command, file.path], cancelled: cancelled, chdir: cwd)
+      end
+    end
+
+    def configured_binary(runner, runner_config, cwd)
+      settings = runner_config.is_a?(Hash) ? (runner_config[runner.to_s] || runner_config[runner]) : nil
+      configured = settings.is_a?(Hash) ? (settings["binary"] || settings[:binary]) : settings
+      binary = configured.nil? ? default_binary(runner) : configured
+      unless binary.is_a?(String) && !binary.strip.empty?
+        raise ArgumentError, "Editor runner #{runner.inspect} binary must be a non-empty string"
+      end
+
+      binary = binary.strip
+      path_like?(binary) ? File.expand_path(binary, cwd) : binary
+    end
+
+    def default_binary(runner)
+      value = DEFAULT_BINARIES[runner]
+      value.respond_to?(:call) ? value.call : value
+    end
+
+    def temporary_directory(cwd, source_path)
+      return cwd if source_path.to_s.empty?
+
+      directory = File.dirname(File.expand_path(source_path, cwd))
+      return directory if Dir.exist?(directory) && File.writable?(directory)
+
+      cwd
+    end
+
+    def path_like?(value)
+      value.include?("/") || value.include?("\\") || value.start_with?("~")
+    end
+
+    def windows_host?
+      RbConfig::CONFIG["host_os"].to_s.match?(/mswin|mingw|cygwin/i)
+    end
+
+    def capture_process(command, cancelled: nil, chdir: nil)
+      options = chdir ? { chdir: chdir } : {}
+      input, output, wait_thread = Open3.popen2e(*command, **options)
+      input.close
+      chunks = []
+      output_size = 0
+      was_cancelled = false
+
+      loop do
+        if !was_cancelled && cancelled&.call
+          terminate_process(wait_thread.pid)
+          was_cancelled = true
+        end
+
+        output_size = read_available_output(output, chunks, output_size)
+        break if wait_thread.join(0)
+
+        sleep POLL_INTERVAL
+      end
+
+      output_size = read_remaining_output(output, chunks, output_size)
+      [chunks.join, wait_thread.value, was_cancelled, output_size >= MAX_OUTPUT_BYTES]
+    ensure
+      if wait_thread&.alive?
+        terminate_process(wait_thread.pid)
+        wait_thread.join
+      end
+      input&.close unless input&.closed?
+      output&.close unless output&.closed?
+    end
+
+    def read_available_output(output, chunks, output_size)
+      ready = IO.select([output], nil, nil, 0)
+      return output_size unless ready
+
+      loop do
+        output_size = append_output(chunks, output.read_nonblock(OUTPUT_READ_SIZE), output_size)
+      rescue IO::WaitReadable, EOFError
+        break
+      end
+      output_size
+    end
+
+    def read_remaining_output(output, chunks, output_size)
+      loop do
+        output_size = append_output(chunks, output.read_nonblock(OUTPUT_READ_SIZE), output_size)
+      end
+    rescue IO::WaitReadable, IOError, EOFError
+      output_size
+    end
+
+    def append_output(chunks, chunk, output_size)
+      return output_size if output_size >= MAX_OUTPUT_BYTES
+
+      remaining = MAX_OUTPUT_BYTES - output_size
+      chunks << chunk.byteslice(0, remaining)
+      output_size + [chunk.bytesize, remaining].min
+    end
+
+    def terminate_process(pid)
+      Process.kill("TERM", pid)
+    rescue Errno::ESRCH
+      nil
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end