kward 0.82.0 → 0.83.0

data/lib/kward/editor_prompt.rb

@@ -0,0 +1,46 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Builds the model-facing request for an in-memory editor prompt.
+  module EditorPrompt
+    module_function
+
+    def system_message
+      {
+        role: "system",
+        content: <<~PROMPT.strip
+          You are Kward's in-memory editor assistant.
+
+          Act only on the user's explicit request about the active editor buffer. Do not volunteer changes, explanations, or unrelated work. For an actionable edit request, call replace_editor_buffer with the complete replacement buffer. For a request that is only a question or needs clarification, answer briefly without changing the buffer. Never write files to disk and never claim that the buffer was saved.
+        PROMPT
+      }
+    end
+
+    def input(instruction, context)
+      document = context[:display_path].to_s
+      language = context[:language].to_s
+      language = "text" if language.empty?
+      content = context[:content].to_s
+
+      <<~PROMPT
+        You are operating inside an interactive editor.
+
+        The user requested:
+        #{instruction}
+
+        Active document: #{document.empty? ? "(untitled)" : document}
+        Language: #{language}
+        Cursor: line #{context.dig(:cursor, 0).to_i + 1}, column #{context.dig(:cursor, 1).to_i + 1}
+        Selected text: #{context[:selection].to_s.empty? ? "(none)" : "present; full-buffer replacement is required"}
+
+        Current buffer:
+        <editor_buffer>
+        #{content}
+        </editor_buffer>
+
+        Satisfy the user's request by calling replace_editor_buffer with the complete desired buffer contents.
+        The operation changes only the in-memory editor buffer. Do not write files to disk.
+        If the request is ambiguous, explain the ambiguity instead of changing the buffer.
+      PROMPT
+    end
+  end
+end

data/lib/kward/editor_prompt_session.rb

@@ -0,0 +1,28 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Transactional draft used while an agent works on an active editor buffer.
+  #
+  # The live terminal editor remains owned by PromptInterface. Agent tool calls
+  # update this draft and the caller commits it only after a successful turn.
+  class EditorPromptSession
+    attr_reader :context, :content
+
+    def initialize(context)
+      @context = context.dup
+      @initial_content = @context.fetch(:content).to_s.dup
+      @content = @initial_content.dup
+    end
+
+    def replace(content)
+      @content = content.to_s
+    end
+
+    def changed?
+      @content != @initial_content
+    end
+
+    def initial_content
+      @initial_content.dup
+    end
+  end
+end

data/lib/kward/ekwsh.rb

@@ -18,17 +18,16 @@ module Kward
     DEFAULT_TIMEOUT_SECONDS = 300
     DEFAULT_MAX_OUTPUT_BYTES = 1_048_576
     DEFAULT_HISTORY_LIMIT = 1_000
+    CONTEXT_OUTPUT_BYTES = 32_000
 
-    attr_reader :cwd
+    attr_reader :cwd, :last_command, :timeout_seconds
 
     def command_shell
       @shell
     end
 
     def child_env(interactive: false)
-      env = @env.dup
-      env.delete("GIT_PAGER") if interactive && @defaulted_git_pager
-      env
+      @env.dup
     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)
@@ -43,6 +42,8 @@ module Kward
       @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
+      @last_command = nil
+      @last_result = nil
     end
 
     def prompt_label
@@ -53,7 +54,45 @@ module Kward
       command = input.to_s.strip
       return Result.new(output: "", exit_status: 0) if command.empty?
 
-      run_expanded_command(command, cancellation: cancellation, &block)
+      result = run_expanded_command(command, cancellation: cancellation, &block)
+      remember_result(command, result)
+      result
+    end
+
+    # Runs a command for the shell assistant without handing it the terminal.
+    # Built-ins still execute in this Ekwsh instance so their state persists.
+    def run_for_agent(input, timeout_seconds: nil, cancellation: nil)
+      command = input.to_s.strip
+      return run(command, cancellation: cancellation) if command.empty?
+
+      result = run(command, cancellation: cancellation)
+      return result unless result.interactive_command
+
+      result = execute(
+        result.interactive_command,
+        display_command: command,
+        timeout_seconds: timeout_seconds,
+        cancellation: cancellation
+      )
+      remember_result(command, result)
+      result
+    end
+
+    # Records the output of an interactive command after terminal handoff.
+    def record_interactive_result(output:, exit_status:)
+      return unless @last_command
+
+      @last_result = Result.new(output: ANSI.sanitize_transcript(output.to_s), exit_status: exit_status)
+    end
+
+    # Returns bounded shell state for an explicit shell-agent prompt.
+    def context_snapshot(max_output_bytes: CONTEXT_OUTPUT_BYTES)
+      {
+        cwd: @cwd,
+        last_command: @last_command,
+        exit_status: @last_result&.exit_status,
+        last_output: context_output(@last_result&.output, max_output_bytes)
+      }
     end
 
     def complete(input, cursor)
@@ -112,8 +151,6 @@ 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
 
@@ -522,12 +559,13 @@ module Kward
       key.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
     end
 
-    def execute(command, display_command: command, cancellation: nil)
+    def execute(command, display_command: command, timeout_seconds: nil, cancellation: nil)
       output = command_echo(display_command)
       streamed = block_given?
       yield output.dup if streamed
+      timeout = effective_timeout(timeout_seconds)
       result = external_command_runner.new(
-        timeout_seconds: @timeout_seconds,
+        timeout_seconds: timeout,
         max_output_bytes: @max_output_bytes,
         terminate_on_output_limit: true
       ).run(@shell, "-c", command, env: @env, cwd: @cwd, cancellation: cancellation) do |_stream, chunk|
@@ -537,7 +575,7 @@ module Kward
       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: command timed out after #{timeout} 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)
@@ -549,6 +587,28 @@ module Kward
       Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 127)
     end
 
+    def effective_timeout(timeout_seconds)
+      timeout = timeout_seconds.to_i
+      timeout.positive? ? timeout : @timeout_seconds
+    end
+
+    def remember_result(command, result)
+      @last_command = command.to_s
+      @last_result = result
+    end
+
+    def context_output(output, max_output_bytes)
+      text = ANSI.sanitize_transcript(output.to_s)
+      limit = max_output_bytes.to_i
+      return text if limit <= 0 || text.bytesize <= limit
+
+      prefix = "[Earlier output omitted; showing the end of the command output.]\n"
+      tail_limit = [limit - prefix.bytesize, 0].max
+      tail = text.byteslice(-tail_limit, tail_limit).to_s if tail_limit.positive?
+      value = "#{prefix}#{tail}"
+      ANSI.normalize_transcript_encoding(value.byteslice(-limit, limit).to_s)
+    end
+
     def external_command_runner
       defined?(LocalPtyCommandRunner) ? LocalPtyCommandRunner : LocalCommandRunner
     end

data/lib/kward/model/client.rb

@@ -906,7 +906,7 @@ module Kward
       request["Content-Type"] = "application/json"
       request["Accept"] = "text/event-stream"
       request.body = request_body || JSON.dump(codex_payload(messages, tools, max_tokens: max_tokens))
-      apply_codex_identity(request, luna: luna_request?(request.body))
+      request["originator"] = "kward"
 
       message = nil
       Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: stream_idle_timeout_seconds) do |http|
@@ -931,22 +931,6 @@ module Kward
       raise e
     end
 
-    def apply_codex_identity(request, luna:)
-      request["originator"] = "kward"
-      return unless luna
-
-      # TODO: Remove this Luna-specific Responses Lite workaround when Codex accepts Kward's own client identity.
-      request["originator"] = "codex_cli_rs"
-      request["User-Agent"] = "codex_cli_rs/0.144.1"
-      request["x-openai-internal-codex-responses-lite"] = "true"
-    end
-
-    def luna_request?(request_body)
-      JSON.parse(request_body)["model"] == "gpt-5.6-luna"
-    rescue JSON::ParserError
-      false
-    end
-
     def parse_codex_sse(body, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil)
       ModelStreamParser.parse_codex_sse(body, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
     end

data/lib/kward/model/model_info.rb

@@ -12,6 +12,7 @@ module Kward
     OPENAI_MODEL_CHOICES = %w[gpt-5.6-sol gpt-5.6-terra gpt-5.6-luna gpt-5.5 gpt-5.4 gpt-5.4-mini gpt-5.3-codex-spark].freeze
     ANTHROPIC_MODEL_CHOICES = %w[
       claude-fable-5
+      claude-opus-5
       claude-opus-4-8
       claude-sonnet-5
       claude-sonnet-4-6
@@ -113,7 +114,7 @@ module Kward
       [/\Agpt-3\.5-turbo/, 16_385]
     ].freeze
     ANTHROPIC_CONTEXT_WINDOWS = [
-      [/\Aclaude-(?:fable|mythos|sonnet)-5(?:\z|-)/, 1_000_000],
+      [/\Aclaude-(?:fable|mythos|opus|sonnet)-5(?:\z|-)/, 1_000_000],
       [/\Aclaude-opus-4-(?:6|7|8)(?:\z|-)/, 1_000_000],
       [/\Aclaude-sonnet-4-6(?:\z|-)/, 1_000_000],
       [/\Aclaude-(?:haiku|opus|sonnet)-4-5(?:\z|-)/, 200_000],
@@ -454,7 +455,7 @@ module Kward
 
     def anthropic_reasoning_effort_choices(id)
       text = normalize_anthropic_model(id)
-      return ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:fable|mythos|sonnet)-5(?:\z|-)|\Aclaude-opus-4-(?:7|8)(?:\z|-)/)
+      return ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:fable|mythos|opus|sonnet)-5(?:\z|-)|\Aclaude-opus-4-(?:7|8)(?:\z|-)/)
       return ANTHROPIC_STANDARD_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:opus-4-6|sonnet-4-6)(?:\z|-)/)
       return ANTHROPIC_OPUS_4_5_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-opus-4-5(?:\z|-)/)
 

data/lib/kward/model/payloads.rb

@@ -189,8 +189,6 @@ module Kward
       unless reasoning == false
         effort = reasoning || reasoning_effort(provider)
         payload[:reasoning] = { effort: effort, summary: "auto" }
-        # TODO: Remove this Luna-specific Responses Lite workaround when Codex accepts Kward's own client identity.
-        payload[:reasoning][:context] = "all_turns" if provider == "Codex" && parts[:model] == "gpt-5.6-luna"
       end
       payload
     end