kward 0.80.0 → 0.81.0

data/lib/kward/ekwsh.rb

@@ -13,7 +13,7 @@ module Kward
   class Ekwsh
     Result = Struct.new(:output, :exit_status, :exit_shell, :clear, :open_editor_path, :interactive_command, :streamed, keyword_init: true)
     Completion = Struct.new(:range, :replacement, :candidates, keyword_init: true)
-    BUILTINS = %w[alias cd pwd export unset unalias clear exit logout pty].freeze
+    BUILTINS = %w[alias capture cd pwd export unset unalias clear exit logout pty].freeze
     DEFAULT_SHELL = "/bin/sh"
     DEFAULT_TIMEOUT_SECONDS = 300
     DEFAULT_MAX_OUTPUT_BYTES = 1_048_576
@@ -72,6 +72,23 @@ module Kward
       Completion.new(range: token[:range], replacement: replacement, candidates: candidates)
     end
 
+    def expand_alias(command, interactive: false)
+      words = shell_words(command)
+      return command if words.empty? || BUILTINS.include?(words.first)
+      return command unless @aliases[words.first]
+
+      rest = command.sub(/\A\s*#{Regexp.escape(words.first)}\b\s*/, "")
+      expanded = [@aliases.fetch(words.first), rest].reject(&:empty?).join(" ")
+      interactive ? expanded.sub(/\A\s*(?:capture|pty)(?:\s+|\z)/, "") : expanded
+    rescue ArgumentError
+      command
+    end
+
+    def editor_command_result(command, display_command: command)
+      expanded_command = expand_alias(command, interactive: true)
+      kward_command_result(expanded_command, display_command: display_command)
+    end
+
     private
 
     def configure_rbenv_environment
@@ -276,7 +293,7 @@ module Kward
       Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
     end
 
-    def builtin_result(command, display_command: command)
+    def builtin_result(command, display_command: command, cancellation: nil, &block)
       words = shell_words(command)
       return nil if words.empty?
       assignment_result = persist_assignments(display_command, words)
@@ -297,6 +314,8 @@ module Kward
         unset_variables(display_command, words)
       when "clear"
         Result.new(output: "", exit_status: 0, clear: true)
+      when "capture"
+        captured_command_result(command, display_command: display_command, cancellation: cancellation, &block)
       when "pty"
         interactive_pty_result(command, display_command: display_command)
       else
@@ -306,13 +325,26 @@ module Kward
       Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
     end
 
+    def captured_command_result(command, display_command:, cancellation: nil, &block)
+      captured_command = command.sub(/\A\s*capture(?:\s+|\z)/, "")
+      if captured_command.empty?
+        return Result.new(output: "#{command_echo(display_command)}Usage: capture <command>\n", exit_status: 2)
+      end
+
+      execute(captured_command, display_command: display_command, cancellation: cancellation, &block)
+    end
+
     def interactive_pty_result(command, display_command: command)
       interactive_command = command.sub(/\A\s*pty(?:\s+|\z)/, "")
       if interactive_command.empty?
         return Result.new(output: "#{command_echo(display_command)}Usage: pty <command>\n", exit_status: 2)
       end
 
-      Result.new(output: "#{command_echo(display_command)}[interactive PTY session started]\n", exit_status: 0, interactive_command: interactive_command)
+      interactive_command_result(interactive_command, display_command: display_command)
+    end
+
+    def interactive_command_result(command, display_command: command)
+      Result.new(output: command_echo(display_command), exit_status: 0, interactive_command: command)
     end
 
     def shell_words(command)
@@ -361,29 +393,18 @@ module Kward
       name.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_-]*\z/) && !BUILTINS.include?(name.to_s)
     end
 
-    def expand_alias(command)
-      words = shell_words(command)
-      return command if words.empty? || BUILTINS.include?(words.first)
-      return command unless @aliases[words.first]
-
-      rest = command.sub(/\A\s*#{Regexp.escape(words.first)}\b\s*/, "")
-      [@aliases.fetch(words.first), rest].reject(&:empty?).join(" ")
-    rescue ArgumentError
-      command
-    end
-
     def run_expanded_command(command, cancellation: nil, &block)
       expanded_command = expand_alias(command)
       exit_result = exit_result(expanded_command, display_command: command)
       return exit_result if exit_result
 
-      builtin_result = builtin_result(expanded_command, display_command: command)
+      builtin_result = builtin_result(expanded_command, display_command: command, cancellation: cancellation, &block)
       return builtin_result if builtin_result
 
       kward_result = kward_command_result(expanded_command, display_command: command)
       return kward_result if kward_result
 
-      execute(expanded_command, display_command: command, cancellation: cancellation, &block)
+      interactive_command_result(expanded_command, display_command: command)
     end
 
     def kward_command_result(command, display_command: command)

data/lib/kward/hooks/audit_log.rb

@@ -11,13 +11,14 @@ module Kward
     class AuditLog
       DEFAULT_MAX_BYTES = 10 * 1024 * 1024
 
-      def initialize(path: nil, config_path: ConfigFiles.config_path, max_bytes: DEFAULT_MAX_BYTES, clock: Time, monotonic_clock: Process, error_output: $stderr)
+      def initialize(path: nil, config_path: ConfigFiles.config_path, max_bytes: DEFAULT_MAX_BYTES, clock: Time, monotonic_clock: Process, error_output: $stderr, warning_sink: nil)
         @path = path
         @config_path = config_path
         @max_bytes = max_bytes.to_i.positive? ? max_bytes.to_i : DEFAULT_MAX_BYTES
         @clock = clock
         @monotonic_clock = monotonic_clock
         @error_output = error_output
+        @warning_sink = warning_sink
         @mutex = Mutex.new
         @warned = false
       end
@@ -112,7 +113,9 @@ module Kward
         return if @warned
 
         @warned = true
-        @error_output&.puts("Warning: hook audit logging failed: #{error.message}")
+        message = "Warning: hook audit logging failed: #{error.message}"
+        sink = @warning_sink || ConfigFiles.warning_sink
+        sink ? sink.call(message) : @error_output&.puts(message)
       rescue StandardError
         nil
       end

data/lib/kward/interactive_pty_runner.rb

@@ -9,7 +9,7 @@ module Kward
   # This is intentionally low level: UI orchestration decides when terminal
   # ownership is handed to the child process and how the result is presented.
   class InteractivePtyRunner
-    Result = Struct.new(:exit_status, keyword_init: true)
+    Result = Struct.new(:exit_status, :input_forwarded, keyword_init: true)
 
     READ_SIZE = 4096
 
@@ -18,34 +18,27 @@ module Kward
       @window_size = nil
     end
 
-    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, output: $stdout)
+    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, output: $stdout, &block)
       pid = nil
       status = nil
+      writer = nil
+      input_forwarded = false
 
-      PTY.spawn(env.to_h, *command, chdir: cwd.to_s) do |reader, writer, child_pid|
+      PTY.spawn(env.to_h, *command, chdir: cwd.to_s) do |reader, child_writer, child_pid|
         pid = child_pid
+        writer = child_writer
         update_window_size(reader, pid)
         with_raw_input(input) do
           drain_initial_input(input, writer)
-          loop do
-            update_window_size(reader, pid)
-            readable = IO.select([reader, input], nil, nil, 0.02)&.first || []
-            forward_pty_output(reader, output) if readable.include?(reader)
-            forward_input(input, writer) if readable.include?(input)
-            if (finished_status = finished_status(pid))
-              status = finished_status
-              break
-            end
-          rescue Errno::EIO, IOError
-            break
-          end
+          status, input_forwarded = forward_io(reader, writer, pid, input, output, &block)
         end
         status ||= wait_for_status(pid)
-      ensure
-        writer&.close unless writer&.closed?
       end
 
-      Result.new(exit_status: exit_status(status))
+      Result.new(exit_status: exit_status(status), input_forwarded: input_forwarded)
+    ensure
+      writer&.close unless writer&.closed?
+      terminate_and_reap(pid) if pid && status.nil?
     end
 
     private
@@ -53,8 +46,14 @@ module Kward
     def with_raw_input(input)
       return yield unless input.respond_to?(:raw)
 
-      input.raw { yield }
+      yielded = false
+      input.raw do
+        yielded = true
+        yield
+      end
     rescue Errno::ENOTTY
+      raise if yielded
+
       yield
     end
 
@@ -70,22 +69,67 @@ module Kward
       nil
     end
 
+    def forward_io(reader, writer, pid, input, output, &block)
+      input_open = true
+      input_forwarded = false
+      loop do
+        update_window_size(reader, pid)
+        readers = [reader]
+        readers << input if input_open
+        readable = IO.select(readers, nil, nil, 0.02)&.first || []
+        forward_pty_output(reader, output, &block) if readable.include?(reader)
+        if input_open && readable.include?(input)
+          input_open, forwarded = forward_input(input, writer)
+          input_forwarded ||= forwarded
+        end
+
+        status = finished_status(pid)
+        next unless status
+
+        return [finish_stopped_process(pid), input_forwarded] if status.stopped?
+
+        drain_pty_output(reader, output, &block)
+        return [status, input_forwarded]
+      rescue Errno::EIO
+        return [wait_for_status(pid), input_forwarded]
+      end
+    end
+
     def forward_pty_output(reader, output)
       chunk = reader.read_nonblock(READ_SIZE, exception: false)
       return if chunk.nil? || chunk == :wait_readable
 
       output.write(chunk)
       output.flush if output.respond_to?(:flush)
+      yield chunk if block_given?
+    end
+
+    def drain_pty_output(reader, output)
+      loop do
+        readable, = IO.select([reader], nil, nil, 0.02)
+        break unless readable
+
+        chunk = reader.read_nonblock(READ_SIZE, exception: false)
+        break if chunk.nil? || chunk == :wait_readable
+
+        output.write(chunk)
+        yield chunk if block_given?
+      end
+      output.flush if output.respond_to?(:flush)
+    rescue Errno::EIO
+      nil
     end
 
     def forward_input(input, writer)
       chunk = input.read_nonblock(READ_SIZE, exception: false)
-      return if chunk.nil? || chunk == :wait_readable
+      return [false, false] if chunk.nil?
+      return [true, false] if chunk == :wait_readable
 
       writer.write(chunk)
       writer.flush
+      [true, true]
     rescue Errno::EIO, Errno::EPIPE, IOError
-      nil
+      [false, false]
     end
 
     def update_window_size(reader, pid)
@@ -111,12 +155,18 @@ module Kward
     def finished_status(pid)
       return unless pid
 
-      finished_pid, status = Process.wait2(pid, Process::WNOHANG)
+      finished_pid, status = Process.wait2(pid, Process::WNOHANG | Process::WUNTRACED)
       status if finished_pid
     rescue Errno::ECHILD
       nil
     end
 
+    def finish_stopped_process(pid)
+      signal_process("CONT", -pid) || signal_process("CONT", pid)
+      terminate_process_group(pid)
+      wait_for_status(pid)
+    end
+
     def wait_for_status(pid)
       return unless pid
 
@@ -134,6 +184,22 @@ module Kward
       1
     end
 
+    def terminate_and_reap(pid)
+      terminate_process_group(pid)
+      wait_for_status(pid)
+    end
+
+    def terminate_process_group(pid)
+      signal_process("TERM", -pid) || signal_process("TERM", pid)
+      deadline = Time.now + 0.2
+      while Time.now < deadline
+        return unless process_running?(pid)
+
+        sleep 0.02
+      end
+      signal_process("KILL", -pid) || signal_process("KILL", pid)
+    end
+
     def process_running?(pid)
       Process.kill(0, pid)
       true

data/lib/kward/plugin_registry.rb

@@ -313,16 +313,19 @@ module Kward
     class << self
       attr_accessor :loading_registry, :loading_path
 
-      def load(paths: ConfigFiles.plugin_paths, reserved_commands: [])
-        registry = new(reserved_commands: reserved_commands)
+      def load(paths: nil, reserved_commands: [], warning_sink: nil)
+        warning_sink ||= ConfigFiles.warning_sink
+        paths ||= ConfigFiles.plugin_paths(warning_sink: warning_sink)
+        registry = new(reserved_commands: reserved_commands, warning_sink: warning_sink)
         paths.each { |path| registry.load_file(path) }
         registry
       end
     end
 
     # Creates an object for trusted plugin loading and dispatch.
-    def initialize(reserved_commands: [])
+    def initialize(reserved_commands: [], warning_sink: nil)
       @reserved_commands = reserved_commands.map(&:to_s)
+      @warning_sink = warning_sink
       @commands = {}
       @interactive_commands = {}
       @tab_types = {}
@@ -419,7 +422,7 @@ module Kward
         rendered = entry[:renderer].call(context)
         parts << rendered.to_s unless rendered.to_s.empty?
       rescue StandardError => e
-        warn "Warning: Kward plugin prompt context error in #{entry[:path]}: #{e.message}"
+        emit_warning "Warning: Kward plugin prompt context error in #{entry[:path]}: #{e.message}"
       end
       parts.empty? ? nil : parts.join("\n\n")
     end
@@ -431,7 +434,7 @@ module Kward
       @transcript_event_handlers.each do |entry|
         entry[:handler].call(transcript_event, context)
       rescue StandardError => e
-        warn "Warning: Kward plugin transcript event error in #{entry[:path]}: #{e.message}"
+        emit_warning "Warning: Kward plugin transcript event error in #{entry[:path]}: #{e.message}"
       end
       nil
     end
@@ -444,7 +447,7 @@ module Kward
       Kernel.load(path, true)
       @paths << path
     rescue StandardError => e
-      warn "Warning: skipping Kward plugin #{path}: #{e.message}"
+      emit_warning "Warning: skipping Kward plugin #{path}: #{e.message}"
     ensure
       self.class.loading_registry = previous_registry
       self.class.loading_path = previous_path
@@ -462,11 +465,11 @@ module Kward
       raise "Plugin command /#{name} requires a handler" unless handler
 
       if @reserved_commands.include?(name)
-        warn "Warning: skipping Kward plugin command /#{name}: reserved command"
+        emit_warning "Warning: skipping Kward plugin command /#{name}: reserved command"
         return nil
       end
       if @commands.key?(name)
-        warn "Warning: skipping duplicate Kward plugin command /#{name}: #{path}"
+        emit_warning "Warning: skipping duplicate Kward plugin command /#{name}: #{path}"
         return nil
       end
 
@@ -485,11 +488,11 @@ module Kward
       raise "Interactive command /#{name} requires a handler" unless handler
 
       if @reserved_commands.include?(name) || @commands.key?(name)
-        warn "Warning: skipping Kward interactive command /#{name}: reserved command"
+        emit_warning "Warning: skipping Kward interactive command /#{name}: reserved command"
         return nil
       end
       if @interactive_commands.key?(name)
-        warn "Warning: skipping duplicate Kward interactive command /#{name}: #{path}"
+        emit_warning "Warning: skipping duplicate Kward interactive command /#{name}: #{path}"
         return nil
       end
 
@@ -512,7 +515,7 @@ module Kward
       raise "Plugin tab type #{name} requires a handler" unless handler
 
       if @tab_types.key?(name) || @tab_types_by_id.key?(id)
-        warn "Warning: skipping duplicate Kward plugin tab type #{id}: #{path}"
+        emit_warning "Warning: skipping duplicate Kward plugin tab type #{id}: #{path}"
         return nil
       end
 
@@ -529,7 +532,7 @@ module Kward
       raise "Plugin transport #{name} requires a handler" unless handler
 
       if @transports.key?(name) || @transports_by_id.key?(id)
-        warn "Warning: skipping duplicate Kward plugin transport #{id}: #{path}"
+        emit_warning "Warning: skipping duplicate Kward plugin transport #{id}: #{path}"
         return nil
       end
 
@@ -543,11 +546,15 @@ module Kward
     def register_footer(path: nil, &renderer)
       raise "Plugin footer requires a renderer" unless renderer
 
-      warn "Warning: replacing Kward plugin footer from #{@footer_path}: #{path}" if @footer
+      emit_warning "Warning: replacing Kward plugin footer from #{@footer_path}: #{path}" if @footer
       @footer = renderer
       @footer_path = path
     end
 
+    def emit_warning(message)
+      @warning_sink ? @warning_sink.call(message) : warn(message)
+    end
+
     def register_transcript_event(path: nil, &handler)
       raise "Plugin transcript event requires a handler" unless handler
 

data/lib/kward/prompt_interface/composer_controller.rb

@@ -256,11 +256,23 @@ module Kward
       def submit_input
         value = submitted_input
         add_history(composer_input)
-        clear_finished_input_locked(reset_history: true)
+        if !@busy && value.strip.empty?
+          @output_io.flush
+          return value
+        end
+
+        clear_submitted_input_locked
         @output_io.flush
         value
       end
 
+      def clear_submitted_input_locked
+        self.composer_input = ""
+        self.composer_cursor = 0
+        @composer.clear_attachments
+        reset_history_search
+      end
+
       def clear_finished_input_locked(reset_history: false)
         if @busy
           clear_prompt_for_output_locked

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

@@ -827,6 +827,10 @@ module Kward
         modifier = sequence[:modifier]
         queue_pending_keys(sequence[:remaining]) if sequence[:remaining] && !sequence[:remaining].empty?
 
+        if ctrl_modifier?(modifier) && ctrl_code(code) == 113
+          return close_editor
+        end
+
         if ctrl_modifier?(modifier) && ctrl_code(code) == 102
           return editor_search_active? ? editor_search_append(key) : editor_search_begin
         end

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

@@ -23,10 +23,12 @@ module Kward
       LANGUAGE_DEFINITIONS = {
         javascript: {
           extensions: %w[.js .jsx .mjs .cjs],
+          block_comment: true,
           keywords: %w[async await break case catch class const continue debugger default delete do else export extends false finally for from function if import in instanceof let new null of return static super switch this throw true try typeof undefined var void while with yield]
         },
         typescript: {
           extensions: %w[.ts .tsx],
+          block_comment: true,
           keywords: %w[abstract any as async await boolean break case catch class const constructor continue debugger declare default delete do else enum export extends false finally for from function if implements import in infer instanceof interface is keyof let module namespace never new null number object of private protected public readonly return static string super switch symbol this throw true try type typeof undefined unknown var void while with yield]
         },
         shell: {
@@ -62,34 +64,42 @@ module Kward
         },
         go: {
           extensions: %w[.go],
+          block_comment: true,
           keywords: %w[break case chan const continue default defer else fallthrough false for func go goto if import interface map nil package range return select struct switch true type var]
         },
         rust: {
           extensions: %w[.rs],
+          block_comment: true,
           keywords: %w[as async await break const continue crate dyn else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type unsafe use where while]
         },
         java: {
           extensions: %w[.java],
+          block_comment: true,
           keywords: %w[abstract assert boolean break byte case catch char class const continue default do double else enum extends false final finally float for if implements import instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transient true try void volatile while]
         },
         csharp: {
           extensions: %w[.cs],
+          block_comment: true,
           keywords: %w[abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while var async await]
         },
         c: {
           extensions: %w[.c .h],
+          block_comment: true,
           keywords: %w[auto break case char const continue default do double else enum extern float for goto if inline int long register restrict return short signed sizeof static struct switch typedef union unsigned void volatile while]
         },
         cpp: {
           extensions: %w[.cc .cpp .cxx .hpp .hh .hxx],
+          block_comment: true,
           keywords: %w[alignas alignof and asm auto bool break case catch char char16_t char32_t class const constexpr const_cast continue decltype default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new noexcept nullptr operator or private protected public register reinterpret_cast return short signed sizeof static static_assert static_cast struct switch template this throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while]
         },
         swift: {
           extensions: %w[.swift],
+          block_comment: true,
           keywords: %w[as associatedtype break case catch class continue default defer deinit do else enum extension false fileprivate for func guard if import in init inout internal is let nil open operator private protocol public repeat rethrows return self Self static struct subscript super switch throw throws true try typealias var where while]
         },
         kotlin: {
           extensions: %w[.kt .kts],
+          block_comment: true,
           keywords: %w[as break class continue do else false for fun if in interface is null object package return super this throw true try typealias typeof val var when while by catch constructor delegate dynamic field file finally get import init param property receiver set setparam where actual abstract annotation companion const crossinline data enum expect external final infix inline inner internal lateinit noinline open operator out override private protected public reified sealed suspend tailrec vararg]
         },
         lua: {
@@ -296,8 +306,7 @@ module Kward
         return line.to_s unless definition
 
         text = line.to_s
-        return colored(text, :gray) if editor_c_style_block_comment_line?(line_index)
-
+        return colored(text, :gray) if definition[:block_comment] && editor_c_style_block_comment_line?(line_index)
         marker = definition[:line_comment] || "//"
         comment_index = editor_comment_index(text, marker)
         return editor_highlight_generic_code(text, definition[:keywords]) unless comment_index
@@ -313,7 +322,8 @@ module Kward
       end
 
       def editor_generic_pattern(keywords)
-        /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b\d+(?:\.\d+)?\b|\b[A-Z]\w*\b|\b(?:#{Regexp.union(keywords)})\b)/
+        @editor_generic_patterns ||= {}
+        @editor_generic_patterns[keywords] ||= /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b\d+(?:\.\d+)?\b|\b[A-Z]\w*\b|\b(?:#{Regexp.union(keywords)})\b)/
       end
 
       def editor_highlight_generic_token(token, keywords)
@@ -333,16 +343,31 @@ module Kward
       def editor_c_style_block_comment_line?(line_index)
         return false unless line_index && @editor_state
 
-        in_comment = false
-        @editor_state.lines.first(line_index.to_i + 1).each_with_index do |line, index|
+        lines = @editor_state.lines
+        unless @editor_block_comment_lines.equal?(lines)
+          @editor_block_comment_lines = lines
+          @editor_block_comment_states = []
+          @editor_block_comment_in_comment = false
+        end
+
+        target = line_index.to_i
+        return false if target.negative?
+        return @editor_block_comment_states[target] if target < @editor_block_comment_states.length
+
+        (@editor_block_comment_states.length..target).each do |index|
+          line = lines[index].to_s
           starts_block = editor_comment_index(line, "/*")
-          ends_block = in_comment && line.include?("*/")
-          return true if index == line_index && (in_comment || starts_block)
+          ends_block = @editor_block_comment_in_comment && line.include?("*/")
+          @editor_block_comment_states << (@editor_block_comment_in_comment || !starts_block.nil?)
 
-          in_comment = true if starts_block && !line[starts_block..].to_s.include?("*/")
-          in_comment = false if ends_block
+          if starts_block && !line[starts_block..].to_s.include?("*/")
+            @editor_block_comment_in_comment = true
+          elsif ends_block
+            @editor_block_comment_in_comment = false
+          end
         end
-        false
+
+        @editor_block_comment_states[target]
       end
 
       def editor_comment_index(line, marker)