kward 0.72.0 → 0.73.1

data/lib/kward/compactor.rb

@@ -130,8 +130,7 @@ module Kward
       end
 
       def tool_calls(message)
-        calls = value(message, :tool_calls)
-        calls.is_a?(Array) ? calls : []
+        MessageAccess.tool_calls(message)
       end
 
       def tool_call_name(tool_call)
@@ -335,7 +334,7 @@ module Kward
 
       def tool_call_args(tool_call)
         function = tool_call["function"] || tool_call[:function] || {}
-        parse_tool_arguments(function["arguments"] || function[:arguments])
+        ToolCall.parse_arguments(function["arguments"] || function[:arguments])
       end
 
       def tool_command(tool_call)
@@ -351,15 +350,6 @@ module Kward
           "#{name}(#{rendered})"
         end
       end
-
-      def parse_tool_arguments(arguments)
-        return {} if arguments.nil? || arguments.empty?
-        return arguments if arguments.is_a?(Hash)
-
-        JSON.parse(arguments)
-      rescue JSON::ParserError
-        {}
-      end
     end
 
     # Compaction support object used by conversation summarization.
@@ -441,7 +431,7 @@ module Kward
       end
 
       def message_role(message)
-        message["role"] || message[:role]
+        MessageAccess.role(message)
       end
     end
 
@@ -518,22 +508,20 @@ module Kward
       end
 
       def compaction_summary(message)
-        message["summary"] || message[:summary] || message["content"] || message[:content]
+        MessageAccess.summary(message) || MessageAccess.content(message)
       end
 
       def compaction_details(message)
-        return {} unless message
-
-        details = message["details"] || message[:details]
+        details = MessageAccess.value(message, :details)
         details.is_a?(Hash) ? details : {}
       end
 
       def entry_id(message, index)
-        message["id"] || message[:id] || "message:#{index}"
+        MessageAccess.value(message, :id) || "message:#{index}"
       end
 
       def message_role(message)
-        message["role"] || message[:role]
+        MessageAccess.role(message)
       end
     end
 

data/lib/kward/config_files.rb

@@ -3,6 +3,7 @@ require "fileutils"
 require "json"
 require "yaml"
 require_relative "private_file"
+require_relative "ekwsh"
 require_relative "editor_mode"
 require_relative "prompts/templates"
 require_relative "skills/registry"
@@ -120,9 +121,11 @@ module Kward
       File.join(cache_dir, "project_browser_state.json")
     end
 
-    def prompt_history_path(cwd, config_dir: self.config_dir)
+    def prompt_history_path(cwd, config_dir: self.config_dir, kind: "prompt")
       key = Digest::SHA256.hexdigest(canonical_workspace_root(cwd))[0, 24]
-      File.join(config_dir, "history", "#{key}.jsonl")
+      return File.join(config_dir, "history", "#{key}.jsonl") if kind.to_s == "prompt"
+
+      File.join(config_dir, "history", kind.to_s, "#{key}.jsonl")
     end
 
     # @return [String] directory containing structured memory files
@@ -170,7 +173,7 @@ module Kward
 
     def read_ekwsh_config(path = ekwsh_config_path)
       path = File.expand_path(path)
-      return { env: {}, aliases: {} } unless File.exist?(path)
+      return normalize_ekwsh_config(nil) unless File.exist?(path)
 
       data = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
       normalize_ekwsh_config(data)
@@ -182,11 +185,30 @@ module Kward
       data = data.transform_keys(&:to_s) if data.is_a?(Hash)
       settings = data.is_a?(Hash) ? data : {}
       {
+        shell: normalize_ekwsh_shell(settings["shell"]),
+        timeout_seconds: normalize_positive_integer(settings["timeout_seconds"], Ekwsh::DEFAULT_TIMEOUT_SECONDS),
+        max_output_bytes: normalize_positive_integer(settings["max_output_bytes"], Ekwsh::DEFAULT_MAX_OUTPUT_BYTES),
+        history_limit: normalize_positive_integer(settings["history_limit"], Ekwsh::DEFAULT_HISTORY_LIMIT),
         env: normalize_ekwsh_env(settings["env"]),
         aliases: normalize_ekwsh_aliases(settings["aliases"])
       }
     end
 
+    def normalize_ekwsh_shell(value)
+      shell = value.to_s.strip
+      return Ekwsh::DEFAULT_SHELL if shell.empty?
+      return shell if shell.start_with?("/") && File.executable?(shell)
+
+      Ekwsh::DEFAULT_SHELL
+    end
+
+    def normalize_positive_integer(value, default)
+      integer = Integer(value)
+      integer.positive? ? integer : default
+    rescue ArgumentError, TypeError
+      default
+    end
+
     def normalize_ekwsh_env(values)
       return {} unless values.is_a?(Hash)
 
@@ -205,7 +227,7 @@ module Kward
       values.each_with_object({}) do |(name, command), result|
         name = name.to_s
         command = command.to_s.strip
-        next unless name.match?(/\A[A-Za-z0-9_.:-]+\z/)
+        next unless Ekwsh.valid_alias_name?(name)
         next if command.empty?
 
         result[name] = command

data/lib/kward/ekwsh.rb

@@ -1,17 +1,37 @@
-require "open3"
 require "shellwords"
+require_relative "ansi"
+require_relative "local_command_runner"
+begin
+  require_relative "local_pty_command_runner"
+rescue LoadError
+  nil
+end
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Kward-native embedded shell command runner.
   class Ekwsh
-    Result = Struct.new(:output, :exit_status, :exit_shell, :clear, :open_editor_path, keyword_init: true)
+    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 clear exit logout].freeze
+    BUILTINS = %w[alias 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
+    DEFAULT_HISTORY_LIMIT = 1_000
 
     attr_reader :cwd
 
-    def initialize(cwd: Dir.pwd, env: ENV.to_h, shell: ENV["SHELL"], configured_env: {}, aliases: {})
+    def command_shell
+      @shell
+    end
+
+    def child_env(interactive: false)
+      env = @env.dup
+      env.delete("GIT_PAGER") if interactive && @defaulted_git_pager
+      env
+    end
+
+    def initialize(cwd: Dir.pwd, env: ENV.to_h, shell: DEFAULT_SHELL, configured_env: {}, aliases: {}, timeout_seconds: DEFAULT_TIMEOUT_SECONDS, max_output_bytes: DEFAULT_MAX_OUTPUT_BYTES)
       @cwd = File.expand_path(cwd.to_s.empty? ? Dir.pwd : cwd.to_s)
       @previous_cwd = nil
       @env = env.to_h.transform_keys(&:to_s).transform_values(&:to_s)
@@ -20,29 +40,31 @@ module Kward
       configure_rbenv_environment
       configure_color_environment
       @aliases = aliases.to_h.transform_keys(&:to_s).transform_values(&:to_s)
-      @shell = shell.to_s.empty? ? "/bin/sh" : shell.to_s
+      @shell = shell.to_s.empty? ? DEFAULT_SHELL : shell.to_s
+      @timeout_seconds = timeout_seconds.to_i.positive? ? timeout_seconds.to_i : DEFAULT_TIMEOUT_SECONDS
+      @max_output_bytes = max_output_bytes.to_i.positive? ? max_output_bytes.to_i : DEFAULT_MAX_OUTPUT_BYTES
     end
 
     def prompt_label
       "Shell #{display_cwd} $"
     end
 
-    def run(input)
+    def run(input, cancellation: nil, &block)
       command = input.to_s.strip
       return Result.new(output: "", exit_status: 0) if command.empty?
-      return Result.new(output: command_echo(command), exit_status: 0, exit_shell: true) if exit_command?(command)
 
-      builtin_result(command) || run_expanded_command(command)
+      run_expanded_command(command, cancellation: cancellation, &block)
     end
 
     def complete(input, cursor)
       token = completion_token(input.to_s, cursor.to_i)
       return nil if token[:command] && token[:text].empty?
 
-      candidates = if token[:command] && !path_like_token?(token[:text])
-                     command_candidates(token[:text])
+      completion_text = token[:path_text] || token[:text]
+      candidates = if token[:command] && !path_like_token?(completion_text) && !token[:quote]
+                     command_candidates(completion_text)
                    else
-                     path_candidates(token[:text], directories_only: cd_completion?(input, token))
+                     path_candidates(completion_text, directories_only: cd_completion?(input, token), quote: token[:quote])
                    end
       return nil if candidates.empty?
 
@@ -73,16 +95,43 @@ module Kward
     def configure_color_environment
       @env["CLICOLOR"] ||= "1"
       @env["COLORTERM"] ||= "truecolor"
+      @defaulted_git_pager = !@env.key?("GIT_PAGER")
+      @env["GIT_PAGER"] ||= "cat"
       @env["TERM"] = "xterm-256color" if @env["TERM"].to_s.empty? || @env["TERM"] == "dumb"
     end
 
     def completion_token(input, cursor)
       cursor = [[cursor, 0].max, input.length].min
-      start_index = cursor
+      start_index = unmatched_quote_start(input[0...cursor]) || cursor
       start_index -= 1 while start_index.positive? && token_character?(input, start_index - 1)
       text = input[start_index...cursor].to_s
       before = input[0...start_index].to_s
-      { range: (start_index...cursor), text: text, command: before.strip.empty? }
+      quote = quoted_completion_token(text)
+      path_text = quote ? text[1..].to_s : nil
+      { range: (start_index...cursor), text: text, path_text: path_text, quote: quote, command: before.strip.empty? }
+    end
+
+    def unmatched_quote_start(text)
+      quote = nil
+      quote_index = nil
+      escaped = false
+      text.to_s.each_char.with_index do |char, index|
+        if escaped
+          escaped = false
+          next
+        end
+        if char == "\\" && quote != "'"
+          escaped = true
+          next
+        end
+        if quote
+          quote = nil if char == quote
+        elsif ["'", '"'].include?(char)
+          quote = char
+          quote_index = index
+        end
+      end
+      quote ? quote_index : nil
     end
 
     def token_character?(input, index)
@@ -109,12 +158,24 @@ module Kward
       text.to_s.include?("/")
     end
 
+    def quoted_completion_token(text)
+      quote = text.to_s[0]
+      return nil unless ["'", '"'].include?(quote)
+      return nil if text[1..].to_s.include?(quote)
+
+      quote
+    end
+
     def command_candidates(prefix)
       (BUILTINS + @aliases.keys + path_executables).uniq.grep(/\A#{Regexp.escape(prefix)}/).sort
     end
 
     def path_executables
-      @env.fetch("PATH", "").split(File::PATH_SEPARATOR).flat_map do |path|
+      path = @env.fetch("PATH", "")
+      return @path_executables_cache if @path_executables_cache_path == path && @path_executables_cache
+
+      @path_executables_cache_path = path
+      @path_executables_cache = path.split(File::PATH_SEPARATOR).flat_map do |path|
         next [] unless File.directory?(path)
 
         Dir.children(path).filter_map do |entry|
@@ -126,7 +187,12 @@ module Kward
       end
     end
 
-    def path_candidates(prefix, directories_only: false)
+    def invalidate_path_executables_cache
+      @path_executables_cache_path = nil
+      @path_executables_cache = nil
+    end
+
+    def path_candidates(prefix, directories_only: false, quote: nil)
       raw_dir, raw_base = split_path_prefix(prefix)
       dir = File.expand_path(unescape_path(raw_dir.empty? ? "." : raw_dir), @cwd)
       return [] unless File.directory?(dir)
@@ -138,7 +204,7 @@ module Kward
         directory = File.directory?(path)
         next if directories_only && !directory
 
-        completed = "#{raw_dir}#{Shellwords.escape(entry)}"
+        completed = path_completion_candidate(raw_dir, entry, quote: quote)
         completed = "#{completed}/" if directory
         completed
       end.sort
@@ -146,6 +212,13 @@ module Kward
       []
     end
 
+    def path_completion_candidate(raw_dir, entry, quote: nil)
+      completed = "#{raw_dir}#{entry}"
+      return "#{quote}#{completed.gsub(quote, "\\#{quote}")}" if quote
+
+      "#{raw_dir}#{Shellwords.escape(entry)}"
+    end
+
     def split_path_prefix(prefix)
       index = prefix.rindex("/")
       return ["", prefix] unless index
@@ -187,35 +260,59 @@ module Kward
     end
 
     def command_echo(command)
-      "$ #{command}\n"
+      ANSI.sanitize_transcript("$ #{command}\n")
     end
 
-    def exit_command?(command)
-      ["exit", "logout"].include?(command)
+    def exit_result(command, display_command: command)
+      words = shell_words(command)
+      return nil unless %w[exit logout].include?(words.first)
+
+      if words.length > 2 || (words[1] && !words[1].match?(/\A\d+\z/))
+        return Result.new(output: "#{command_echo(display_command)}ekwsh: #{words.first}: numeric status expected\n", exit_status: 2)
+      end
+
+      Result.new(output: command_echo(display_command), exit_status: words[1].to_i, exit_shell: true)
+    rescue ArgumentError => e
+      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
     end
 
-    def builtin_result(command)
+    def builtin_result(command, display_command: command)
       words = shell_words(command)
       return nil if words.empty?
+      assignment_result = persist_assignments(display_command, words)
+      return assignment_result if assignment_result
 
       case words.first
       when "alias"
-        list_aliases(command, words)
+        list_aliases(display_command, words)
+      when "unalias"
+        remove_aliases(display_command, words)
       when "cd"
-        change_directory(command, words)
+        change_directory(display_command, words)
       when "pwd"
-        Result.new(output: "#{command_echo(command)}#{@cwd}\n", exit_status: 0)
+        print_working_directory(display_command, words)
       when "export"
-        export_variables(command, words)
+        export_variables(display_command, words)
       when "unset"
-        unset_variables(command, words)
+        unset_variables(display_command, words)
       when "clear"
         Result.new(output: "", exit_status: 0, clear: true)
+      when "pty"
+        interactive_pty_result(command, display_command: display_command)
       else
         nil
       end
     rescue ArgumentError => e
-      Result.new(output: "#{command_echo(command)}ekwsh: #{e.message}\n", exit_status: 2)
+      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
+    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)
     end
 
     def shell_words(command)
@@ -236,12 +333,31 @@ module Kward
       return Result.new(output: "#{command_echo(command)}ekwsh: alias: invalid name: #{invalid.join(" ")}\n", exit_status: 2) unless invalid.empty?
 
       names = @aliases.keys.sort if names.empty? && assignments.empty?
-      lines = names.filter_map { |name| @aliases[name] ? "#{name}=#{Shellwords.escape(@aliases.fetch(name))}" : nil }
+      lines = names.filter_map { |name| @aliases[name] ? "alias #{name}=#{Shellwords.escape(@aliases.fetch(name))}" : nil }
       suffix = lines.empty? ? "" : "#{lines.join("\n")}\n"
       Result.new(output: "#{command_echo(command)}#{suffix}", exit_status: 0)
     end
 
+    def remove_aliases(command, words)
+      if words[1] == "-a" && words.length == 2
+        @aliases.clear
+        return Result.new(output: command_echo(command), exit_status: 0)
+      end
+      if words.length < 2 || words.drop(1).any? { |word| word.start_with?("-") }
+        return Result.new(output: "#{command_echo(command)}Usage: unalias name ... | unalias -a\n", exit_status: 2)
+      end
+
+      missing = words.drop(1).reject { |name| @aliases.delete(name) }
+      return Result.new(output: "#{command_echo(command)}ekwsh: unalias: not found: #{missing.join(" ")}\n", exit_status: 1) unless missing.empty?
+
+      Result.new(output: command_echo(command), exit_status: 0)
+    end
+
     def valid_alias_name?(name)
+      self.class.valid_alias_name?(name)
+    end
+
+    def self.valid_alias_name?(name)
       name.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_-]*\z/) && !BUILTINS.include?(name.to_s)
     end
 
@@ -256,12 +372,18 @@ module Kward
       command
     end
 
-    def run_expanded_command(command)
+    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)
+      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)
+      execute(expanded_command, display_command: command, cancellation: cancellation, &block)
     end
 
     def kward_command_result(command, display_command: command)
@@ -284,7 +406,34 @@ module Kward
       File.basename(words[0].to_s) == "kward"
     end
 
+    def persist_assignments(command, words)
+      return nil unless words.all? { |word| assignment_word?(word) }
+
+      words.each do |assignment|
+        key, value = assignment.split("=", 2)
+        set_env(key, value.to_s)
+      end
+      Result.new(output: command_echo(command), exit_status: 0)
+    end
+
+    def assignment_word?(word)
+      key, value = word.to_s.split("=", 2)
+      !value.nil? && valid_env_key?(key)
+    end
+
+    def print_working_directory(command, words)
+      if words.length > 2 || (words[1] && !%w[-L -P].include?(words[1]))
+        return Result.new(output: "#{command_echo(command)}Usage: pwd [-L|-P]\n", exit_status: 2)
+      end
+
+      Result.new(output: "#{command_echo(command)}#{@cwd}\n", exit_status: 0)
+    end
+
     def change_directory(command, words)
+      if words.length > 2
+        return Result.new(output: "#{command_echo(command)}ekwsh: cd: too many arguments\n", exit_status: 2)
+      end
+
       target = words[1]
       target = Dir.home if target.nil? || target.empty?
       target = @previous_cwd || @cwd if target == "-"
@@ -303,7 +452,7 @@ module Kward
     end
 
     def export_variables(command, words)
-      if words.length == 1
+      if words.length == 1 || words == ["export", "-p"]
         lines = @env.keys.sort.map { |key| "export #{key}=#{Shellwords.escape(@env.fetch(key))}" }
         return Result.new(output: "#{command_echo(command)}#{lines.join("\n")}\n", exit_status: 0)
       end
@@ -311,10 +460,10 @@ module Kward
       invalid = []
       words.drop(1).each do |assignment|
         key, value = assignment.split("=", 2)
-        if value.nil? || !valid_env_key?(key)
+        if !valid_env_key?(key) || assignment.start_with?("-")
           invalid << assignment
         else
-          @env[key] = value
+          set_env(key, value.nil? ? "" : value)
         end
       end
 
@@ -326,8 +475,10 @@ module Kward
     end
 
     def unset_variables(command, words)
-      invalid = words.drop(1).reject { |key| valid_env_key?(key) }
-      words.drop(1).each { |key| @env.delete(key) if valid_env_key?(key) }
+      names = words.drop(1)
+      names.shift if names.first == "--"
+      invalid = names.select { |key| key.start_with?("-") || !valid_env_key?(key) }
+      names.each { |key| delete_env(key) if valid_env_key?(key) }
 
       if invalid.empty?
         Result.new(output: command_echo(command), exit_status: 0)
@@ -336,26 +487,72 @@ module Kward
       end
     end
 
+    def set_env(key, value)
+      @env[key] = value
+      invalidate_path_executables_cache if key == "PATH"
+    end
+
+    def delete_env(key)
+      @env.delete(key)
+      invalidate_path_executables_cache if key == "PATH"
+    end
+
     def valid_env_key?(key)
       key.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
     end
 
-    def execute(command, display_command: command)
-      stdout, stderr, status = Open3.capture3(@env, @shell, "-c", command, chdir: @cwd)
-      exit_status = status.exitstatus || 1
+    def execute(command, display_command: command, cancellation: nil)
       output = command_echo(display_command)
-      output << clean_output(stdout)
-      output << clean_output(stderr)
-      output << "Exit status: #{exit_status}\n" unless exit_status.zero?
-      Result.new(output: output, exit_status: exit_status)
+      streamed = block_given?
+      yield output.dup if streamed
+      result = external_command_runner.new(
+        timeout_seconds: @timeout_seconds,
+        max_output_bytes: @max_output_bytes,
+        terminate_on_output_limit: true
+      ).run(@shell, "-c", command, env: @env, cwd: @cwd, cancellation: cancellation) do |_stream, chunk|
+        text = clean_chunk(chunk)
+        output << text
+        yield text if streamed
+      end
+      append_output_newline(output) { |text| yield text if streamed }
+      exit_status = result.timed_out || result.truncated ? 1 : (result.exit_status || 1)
+      append_streamed(output, "ekwsh: command timed out after #{@timeout_seconds} seconds\n", streamed) { |text| yield text } if result.timed_out
+      append_streamed(output, "ekwsh: output exceeded #{@max_output_bytes} bytes; command terminated\n", streamed) { |text| yield text } if result.truncated
+      append_streamed(output, "Exit status: #{exit_status}\n", streamed) { |text| yield text } unless exit_status.zero?
+      Result.new(output: output, exit_status: exit_status, streamed: streamed)
+    rescue Cancellation::CancelledError
+      append_output_newline(output) { |text| yield text if streamed }
+      append_streamed(output, "^C\nExit status: 130\n", streamed) { |text| yield text }
+      Result.new(output: output, exit_status: 130, streamed: streamed)
     rescue Errno::ENOENT => e
       Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 127)
     end
 
-    def clean_output(value)
+    def external_command_runner
+      defined?(LocalPtyCommandRunner) ? LocalPtyCommandRunner : LocalCommandRunner
+    end
+
+    def append_streamed(output, text, streamed)
+      output << text
+      yield text if streamed && block_given?
+    end
+
+    def append_output_newline(output)
+      return if output.end_with?("\n") || output.empty?
+
+      output << "\n"
+      yield "\n"
+    end
+
+    def clean_chunk(value)
       text = value.to_s.dup
       text.force_encoding(Encoding::UTF_8)
       text = text.valid_encoding? ? text : text.scrub
+      ANSI.sanitize_transcript(text)
+    end
+
+    def clean_output(value)
+      text = clean_chunk(value)
       text.end_with?("\n") || text.empty? ? text : "#{text}\n"
     end
   end

data/lib/kward/image_attachments.rb

@@ -47,7 +47,9 @@ module Kward
     def display_text_without_references(text, references)
       references.reduce(text.to_s.dup) do |result, reference|
         source = reference[:source_text].to_s
-        source.empty? ? result : result.sub(source, "")
+        next result if source.empty?
+
+        result.sub(source, "").sub(Shellwords.escape(source), "")
       end.gsub(/[ \t]{2,}/, " ").gsub(/[ \t]+\n/, "\n").strip
     end