kward 0.83.0 → 0.85.0

data/lib/kward/shell/kwshrc.rb

@@ -0,0 +1,233 @@
+require "shellwords"
+require_relative "kwsh"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Parses the declarative subset of a shell startup file used by kwsh.
+  #
+  # Only aliases, exports, and source directives are handled. Other shell
+  # syntax is intentionally ignored until kwsh supports scripting.
+  class Kwshrc
+    VARIABLE_NAME = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+    VARIABLE_PATTERN = /[A-Za-z_][A-Za-z0-9_]*/
+
+    class ParseError < StandardError
+    end
+
+    def self.read(paths, env: ENV.to_h)
+      new(env: env).read(paths)
+    end
+
+    def self.read_file(path, env: ENV.to_h)
+      parser = new(env: env)
+      parser.read_path(path)
+    end
+
+    def self.resolve_path(path, cwd:, env: ENV.to_h)
+      parser = new(env: env)
+      expanded = parser.send(:expand_variables, path.to_s)
+      expanded = expanded.sub(/\A~(?=\/|\z)/, Dir.home)
+      File.expand_path(expanded, cwd)
+    end
+
+    def initialize(env: ENV.to_h)
+      @environment = env.to_h.transform_keys(&:to_s).transform_values(&:to_s)
+      @exports = {}
+      @aliases = {}
+      @loading = []
+    end
+
+    def read(paths)
+      Array(paths).each { |path| read_file(path, required: false) }
+      configuration
+    end
+
+    def read_path(path)
+      read_file(path, required: true)
+      configuration
+    end
+
+    private
+
+    def configuration
+      { env: @exports, aliases: @aliases }
+    end
+
+    def read_file(path, required:)
+      path = File.expand_path(path.to_s)
+      unless File.file?(path)
+        raise ParseError, "#{path}: file not found" if required
+        return
+      end
+      raise ParseError, "#{path}: recursive source" if @loading.include?(path)
+
+      @loading << path
+      File.foreach(path).with_index(1) do |line, line_number|
+        parse_line(strip_comment(line).strip, path, line_number)
+      end
+    rescue Errno::EACCES, Errno::EISDIR, Errno::ENOENT => e
+      raise ParseError, "#{path}: #{e.message}"
+    ensure
+      @loading.delete(path)
+    end
+
+    def parse_line(line, path, line_number)
+      return if line.empty?
+
+      words = Shellwords.split(line)
+      return if words.empty?
+
+      case words.shift
+      when "alias"
+        parse_aliases(words)
+      when "export"
+        parse_exports(expand_variables(line), path, line_number)
+      when "source", "."
+        parse_source(expand_variables(line), path, line_number)
+      end
+    rescue ArgumentError => e
+      raise ParseError, "#{path}:#{line_number}: #{e.message}"
+    end
+
+    def parse_aliases(words)
+      words.each do |assignment|
+        name, command = assignment.split("=", 2)
+        next unless command && Kwsh.valid_alias_name?(name)
+        next if command.empty?
+
+        @aliases[name] = command
+      end
+    end
+
+    def parse_exports(line, path, line_number)
+      words = Shellwords.split(line)
+      assignments = words.drop(1)
+      raise ParseError, "#{path}:#{line_number}: export requires a variable" if assignments.empty?
+
+      assignments.each do |assignment|
+        name, value = assignment.split("=", 2)
+        next unless name.match?(VARIABLE_NAME)
+
+        value = @environment[name] if value.nil? && @environment.key?(name)
+        next if value.nil?
+
+        @environment[name] = value
+        @exports[name] = value
+      end
+    rescue ArgumentError => e
+      raise ParseError, "#{path}:#{line_number}: #{e.message}"
+    end
+
+    def parse_source(line, path, line_number)
+      words = Shellwords.split(line)
+      source_path = words[1]
+      if words.length != 2 || source_path.to_s.empty?
+        raise ParseError, "#{path}:#{line_number}: source requires one file"
+      end
+
+      source_path = File.expand_path(source_path, File.dirname(path))
+      read_file(source_path, required: true)
+    rescue ArgumentError => e
+      raise ParseError, "#{path}:#{line_number}: #{e.message}"
+    end
+
+    def strip_comment(line)
+      result = +""
+      quote = nil
+      escaped = false
+
+      line.each_char do |character|
+        if escaped
+          result << character
+          escaped = false
+        elsif character == "\\" && quote != "'"
+          result << character
+          escaped = true
+        elsif quote
+          result << character
+          quote = nil if character == quote
+        elsif character == "'" || character == '"'
+          result << character
+          quote = character
+        elsif character == "#"
+          break
+        else
+          result << character
+        end
+      end
+      result
+    end
+
+    def expand_variables(text)
+      result = +""
+      quote = nil
+      escaped = false
+      index = 0
+
+      while index < text.length
+        character = text[index]
+        if escaped
+          result << character
+          escaped = false
+          index += 1
+          next
+        end
+        if character == "\\" && quote != "'"
+          result << character
+          escaped = true
+          index += 1
+          next
+        end
+        if character == "'"
+          quote = if quote == "'"
+            nil
+          elsif quote.nil?
+            character
+          else
+            quote
+          end
+          result << character
+          index += 1
+          next
+        end
+        if character == '"'
+          quote = if quote == '"'
+            nil
+          elsif quote.nil?
+            character
+          else
+            quote
+          end
+          result << character
+          index += 1
+          next
+        end
+
+        if character == "$" && quote != "'"
+          name, length = variable_at(text, index)
+          if name
+            result << @environment.fetch(name, "")
+            index += length
+            next
+          end
+        end
+
+        result << character
+        index += 1
+      end
+      result
+    end
+
+    def variable_at(text, index)
+      if text[index + 1] == "{"
+        closing = text.index("}", index + 2)
+        name = text[(index + 2)...closing] if closing
+        return [name, closing - index + 1] if name&.match?(VARIABLE_NAME)
+      else
+        match = text[(index + 1)..].match(/\A#{VARIABLE_PATTERN}/)
+        return [match[0], match[0].length + 1] if match
+      end
+      nil
+    end
+  end
+end

data/lib/kward/{persistent_shell_session.rb → shell/persistent_session.rb}

@@ -2,9 +2,11 @@ require "io/console"
 require "pty"
 require "securerandom"
 require "shellwords"
-require_relative "ansi"
-require_relative "ekwsh"
-require_relative "local_pty_command_runner"
+require_relative "../terminal/ansi"
+require_relative "kwsh"
+require_relative "kwshrc"
+require_relative "../pty/local_pty_runner"
+require_relative "../pty/detached_run"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -13,8 +15,8 @@ module Kward
   # The process is kept alive between commands so shell variables, functions,
   # aliases, directory changes, and child-shell state belong to one session.
   class PersistentShellSession
-    Result = Ekwsh::Result
-    InteractiveResult = Struct.new(:exit_status, :input_forwarded, keyword_init: true)
+    Result = Kwsh::Result
+    InteractiveResult = Struct.new(:exit_status, :input_forwarded, :tab_action, :background, keyword_init: true)
 
     class CommandInterrupted < StandardError
       attr_reader :protocol
@@ -38,14 +40,14 @@ module Kward
 
     attr_reader :cwd, :last_command, :timeout_seconds
 
-    def initialize(cwd: Dir.pwd, env: ENV.to_h, shell: Ekwsh::DEFAULT_SHELL, configured_env: {}, aliases: {}, timeout_seconds: Ekwsh::DEFAULT_TIMEOUT_SECONDS, max_output_bytes: Ekwsh::DEFAULT_MAX_OUTPUT_BYTES, window_size_provider: nil)
+    def initialize(cwd: Dir.pwd, env: ENV.to_h, shell: Kwsh::DEFAULT_SHELL, configured_env: {}, aliases: {}, timeout_seconds: Kwsh::DEFAULT_TIMEOUT_SECONDS, max_output_bytes: Kwsh::DEFAULT_MAX_OUTPUT_BYTES, window_size_provider: nil)
       @cwd = File.expand_path(cwd.to_s.empty? ? Dir.pwd : cwd.to_s)
       @base_env = env.to_h.transform_keys(&:to_s).transform_values(&:to_s)
       @configured_env = configured_env.to_h.transform_keys(&:to_s).transform_values(&:to_s)
       @aliases = aliases.to_h.transform_keys(&:to_s).transform_values(&:to_s)
-      @shell = shell.to_s.empty? ? Ekwsh::DEFAULT_SHELL : shell.to_s
-      @timeout_seconds = timeout_seconds.to_i.positive? ? timeout_seconds.to_i : Ekwsh::DEFAULT_TIMEOUT_SECONDS
-      @max_output_bytes = max_output_bytes.to_i.positive? ? max_output_bytes.to_i : Ekwsh::DEFAULT_MAX_OUTPUT_BYTES
+      @shell = shell.to_s.empty? ? Kwsh::DEFAULT_SHELL : shell.to_s
+      @timeout_seconds = timeout_seconds.to_i.positive? ? timeout_seconds.to_i : Kwsh::DEFAULT_TIMEOUT_SECONDS
+      @max_output_bytes = max_output_bytes.to_i.positive? ? max_output_bytes.to_i : Kwsh::DEFAULT_MAX_OUTPUT_BYTES
       @window_size_provider = window_size_provider
       @last_command = nil
       @last_result = nil
@@ -93,6 +95,8 @@ module Kward
         capture_result(command, expanded_command, cancellation: cancellation, &block)
       elsif words.first == "pty"
         interactive_result(command, expanded_command)
+      elsif %w[source .].include?(words.first)
+        source_result(command, words)
       elsif (editor_result = editor_command_result(command))
         editor_result
       elsif stateful_command?(words)
@@ -103,7 +107,7 @@ module Kward
       remember_result(command, result)
       result
     rescue ArgumentError => e
-      result = Result.new(output: "#{command_echo(command)}ekwsh: #{e.message}\n", exit_status: 2)
+      result = Result.new(output: "#{command_echo(command)}kwsh: #{e.message}\n", exit_status: 2)
       remember_result(command, result)
       result
     end
@@ -129,14 +133,16 @@ module Kward
 
     # Runs an external command through the same persistent shell process while
     # the caller owns the terminal.
-    def run_interactive(command, input:, sink:)
+    def run_interactive(command, input:, sink:, tab_action_handler: nil, on_detach: nil)
       protocol = with_raw_input(input) do
-        execute_protocol(command, input: input, sink: sink)
+        execute_protocol(command, input: input, sink: sink, tab_action_handler: tab_action_handler, on_detach: on_detach)
       end
-      update_cwd(protocol[:cwd])
+      update_cwd(protocol[:cwd]) unless protocol[:background]
       InteractiveResult.new(
         exit_status: protocol[:status] || 1,
-        input_forwarded: protocol[:input_forwarded]
+        input_forwarded: protocol[:input_forwarded],
+        tab_action: protocol[:tab_action],
+        background: protocol[:background]
       )
     ensure
       sink.finish if sink.respond_to?(:finish)
@@ -150,7 +156,7 @@ module Kward
     end
 
     # Returns bounded shell state for an explicit shell-agent prompt.
-    def context_snapshot(max_output_bytes: Ekwsh::CONTEXT_OUTPUT_BYTES)
+    def context_snapshot(max_output_bytes: Kwsh::CONTEXT_OUTPUT_BYTES)
       {
         cwd: @cwd,
         last_command: @last_command,
@@ -207,7 +213,7 @@ module Kward
     end
 
     def build_routing_shell
-      Ekwsh.new(
+      Kwsh.new(
         cwd: @cwd,
         env: @env || @base_env,
         shell: @shell,
@@ -253,7 +259,7 @@ module Kward
       update_cwd(protocol[:cwd])
     end
 
-    def execute_protocol(command, input: nil, sink: nil, timeout_seconds: nil, max_output_bytes: @max_output_bytes, cancellation: nil, suppress_git_pager: false)
+    def execute_protocol(command, input: nil, sink: nil, timeout_seconds: nil, max_output_bytes: @max_output_bytes, cancellation: nil, suppress_git_pager: false, tab_action_handler: nil, on_detach: nil)
       @command_mutex.synchronize do
         ensure_open
         cancellation&.raise_if_cancelled!
@@ -265,11 +271,13 @@ module Kward
           sink: sink,
           timeout_seconds: timeout_seconds,
           max_output_bytes: max_output_bytes,
-          cancellation: cancellation
+          cancellation: cancellation,
+          tab_action_handler: tab_action_handler,
+          on_detach: on_detach
         )
       end
     rescue CommandInterrupted => e
-      restart_process
+      restart_process unless e.protocol[:background]
       e.protocol
     rescue IOError
       close
@@ -320,8 +328,8 @@ module Kward
       [setup, restore]
     end
 
-    def read_until_marker(marker, input:, sink:, timeout_seconds:, max_output_bytes:, cancellation:)
-      buffer = +"".b
+    def read_until_marker(marker, input:, sink:, timeout_seconds:, max_output_bytes:, cancellation:, tab_action_handler: nil, on_detach: nil, initial_buffer: nil)
+      buffer = initial_buffer ? initial_buffer.dup : +"".b
       captured = +"".b
       captured_bytes = 0
       truncated = false
@@ -411,9 +419,45 @@ module Kward
           if input_chunk.nil?
             input = nil
           elsif input_chunk != :wait_readable
-            notify_input_forwarded(sink)
-            write_raw(input_chunk)
-            input_forwarded = true
+            filtered = tab_action_handler&.call(input_chunk)
+            input_chunk = filtered[:input].to_s if filtered
+            unless input_chunk.empty?
+              notify_input_forwarded(sink)
+              write_raw(input_chunk)
+              input_forwarded = true
+            end
+            if filtered && filtered[:tab_action]
+              if on_detach
+                detached_sink = on_detach.call
+                detached = detach_protocol(
+                  marker,
+                  sink: detached_sink,
+                  timeout_seconds: timeout_seconds,
+                  max_output_bytes: max_output_bytes,
+                  initial_buffer: buffer,
+                  input_forwarded: input_forwarded
+                )
+                raise CommandInterrupted.new(
+                  output: captured,
+                  status: 0,
+                  cwd: @cwd,
+                  input_forwarded: input_forwarded,
+                  tab_action: filtered[:tab_action],
+                  truncated: truncated,
+                  background: detached
+                )
+              end
+
+              interrupt_process
+              raise CommandInterrupted.new(
+                output: captured,
+                status: 130,
+                cwd: @cwd,
+                input_forwarded: input_forwarded,
+                tab_action: filtered[:tab_action],
+                truncated: truncated
+              )
+            end
           end
         end
         update_window_size
@@ -422,6 +466,30 @@ module Kward
       raise IOError, "The embedded shell exited before completing the command."
     end
 
+    def detach_protocol(marker, sink:, timeout_seconds:, max_output_bytes:, initial_buffer:, input_forwarded:)
+      DetachedRun.new(sink: sink, canceler: method(:interrupt_process)) do
+        begin
+          protocol = read_until_marker(
+            marker,
+            input: nil,
+            sink: sink,
+            timeout_seconds: timeout_seconds,
+            max_output_bytes: max_output_bytes,
+            cancellation: nil,
+            initial_buffer: initial_buffer
+          )
+          update_cwd(protocol[:cwd])
+          InteractiveResult.new(
+            exit_status: protocol[:status] || 1,
+            input_forwarded: input_forwarded || protocol[:input_forwarded],
+            background: nil
+          )
+        ensure
+          sink.finish if sink.respond_to?(:finish)
+        end
+      end
+    end
+
     def extract_marker(buffer, marker)
       match = buffer.match(/#{Regexp.escape(marker)}:(-?\d+):(.*?)\r?\n/m)
       return nil unless match
@@ -494,10 +562,10 @@ module Kward
       append_output_newline(output)
       status = protocol[:status] || 1
       if protocol[:timed_out]
-        output << "ekwsh: command timed out after #{effective_timeout(timeout_seconds)} seconds\n"
+        output << "kwsh: command timed out after #{effective_timeout(timeout_seconds)} seconds\n"
         status = 1
       elsif protocol[:truncated]
-        output << "ekwsh: output exceeded #{@max_output_bytes} bytes; output truncated\n"
+        output << "kwsh: output exceeded #{@max_output_bytes} bytes; output truncated\n"
         status = 1
       elsif cancellation&.cancelled?
         output << "^C\n" unless output.end_with?("^C\n")
@@ -509,6 +577,31 @@ module Kward
       Result.new(output: output, exit_status: status, streamed: block_given?)
     end
 
+    def source_result(command, words)
+      unless words.length == 2
+        return Result.new(output: "#{command_echo(command)}Usage: source <file>\n", exit_status: 2)
+      end
+
+      path = Kwshrc.resolve_path(words[1], cwd: @cwd, env: @env)
+      config = Kwshrc.read_file(path, env: @env)
+      exports = config[:env]
+      if exports.any?
+        assignments = exports.map { |key, value| "#{key}=#{Shellwords.escape(value)}" }
+        protocol = execute_protocol("export #{assignments.join(" ")}", timeout_seconds: STARTUP_TIMEOUT_SECONDS, max_output_bytes: nil)
+        unless protocol[:status].to_i.zero?
+          return Result.new(output: "#{command_echo(command)}kwsh: source: could not apply environment\n", exit_status: 1)
+        end
+      end
+
+      @env.merge!(exports)
+      @aliases.merge!(config[:aliases])
+      @routing_shell = build_routing_shell
+      @completion_shell = nil
+      Result.new(output: command_echo(command), exit_status: 0)
+    rescue Kwshrc::ParseError => e
+      Result.new(output: "#{command_echo(command)}kwsh: source: #{e.message}\n", exit_status: 1)
+    end
+
     def capture_result(command, expanded_command, cancellation: nil, &block)
       captured_command = expanded_command.sub(/\A\s*capture(?:\s+|\z)/, "")
       if captured_command.empty?
@@ -535,7 +628,7 @@ module Kward
 
     def exit_result(command, words)
       if words.length > 2 || (words[1] && !words[1].match?(/\A\d+\z/))
-        return Result.new(output: "#{command_echo(command)}ekwsh: #{words.first}: numeric status expected\n", exit_status: 2)
+        return Result.new(output: "#{command_echo(command)}kwsh: #{words.first}: numeric status expected\n", exit_status: 2)
       end
 
       Result.new(output: command_echo(command), exit_status: words[1].to_i, exit_shell: true)
@@ -555,7 +648,7 @@ module Kward
         before = @aliases.dup
         words.drop(1).each do |assignment|
           name, value = assignment.split("=", 2)
-          @aliases[name] = value.to_s if value && Ekwsh.valid_alias_name?(name)
+          @aliases[name] = value.to_s if value && Kwsh.valid_alias_name?(name)
         end
         before != @aliases
       when "unalias"

data/lib/kward/{shell_prompt.rb → shell/prompt.rb}

@@ -16,6 +16,8 @@ module Kward
 
           Use prepare_shell_command when the user asks you to suggest or prepare a command. It places the complete command in the shell prompt but does not execute it; the user must press Enter. Never claim that a prepared command was executed.
 
+          When available, use open_editor if the user explicitly asks to open an existing workspace file in Kward's integrated editor. Opening the editor does not modify or save the file.
+
           Do not execute interactive commands, request passwords, or silently run commands that the user did not explicitly request. If a command needs terminal input, prepare it for the user instead.
         PROMPT
       }

data/lib/kward/{shell_prompt_session.rb → shell/prompt_session.rb}

@@ -1,4 +1,4 @@
-require_relative "ansi"
+require_relative "../terminal/ansi"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/skills/trust_store.rb

@@ -1,7 +1,7 @@
 require "digest"
 require "json"
 require "pathname"
-require_relative "../path_guard"
+require_relative "../workspace/path_guard"
 require_relative "../private_file"
 
 # Namespace for Agent Skills discovery and trust management.