kward 0.82.0 → 0.84.0

data/lib/kward/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/markdown_code_block.rb

@@ -0,0 +1,136 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Finds fenced Markdown code blocks and manages their adjacent output fields.
+  class MarkdownCodeBlock
+    Block = Struct.new(
+      :source, :open_line, :close_line, :language, :body_start, :body_end, :close_end, :next_fence_start,
+      keyword_init: true
+    ) do
+      def code
+        source[body_start...body_end].to_s
+      end
+
+      def output_match
+        limit = next_fence_start || source.length
+        match = source.match(/<output\b[^>]*>.*?<\/output>/mi, close_end)
+        match if match && match.begin(0) < limit && match.end(0) <= limit
+      end
+
+      def output_edit(output)
+        replacement = MarkdownCodeBlock.format_output(output, newline: newline)
+        match = output_match
+        if match
+          [match.begin(0), match.end(0), replacement]
+        else
+          insertion = if source[close_end - newline.length, newline.length] == newline
+                         "#{newline}#{replacement}#{newline}"
+                       else
+                         "#{newline}#{newline}#{replacement}#{newline}"
+                       end
+          [close_end, close_end, insertion]
+        end
+      end
+
+      def with_output(output)
+        start_index, end_index, replacement = output_edit(output)
+        source.dup.tap { |content| content[start_index...end_index] = replacement }
+      end
+
+      private
+
+      def newline
+        source[body_end...close_end].to_s.end_with?("\r\n") ? "\r\n" : "\n"
+      end
+    end
+
+    Fence = Struct.new(:line, :start, :finish, :marker, :length, :language, :close_line, :close_start, :close_end, keyword_init: true)
+
+    class << self
+      def for_selection(source, first_line, last_line)
+        blocks = parse(source)
+        candidates = blocks.select do |block|
+          full_fence = first_line == block.open_line && last_line == block.close_line
+          body_only = block.open_line < first_line && last_line < block.close_line
+          full_fence || body_only
+        end
+        candidates.min_by { |block| block.close_line - block.open_line }
+      end
+
+      def for_cursor(source, line)
+        parse(source).select do |block|
+          block.open_line <= line && line <= block.close_line
+        end.min_by { |block| block.close_line - block.open_line }
+      end
+
+      def parse(source)
+        source = source.to_s
+        lines = source.lines
+        fences = []
+        open_fences = []
+        offset = 0
+
+        lines.each_with_index do |line, line_number|
+          content = line.chomp
+          if (match = content.match(/\A\s*(`{3,}|~{3,})(.*)\z/))
+            marker = match[1][0]
+            length = match[1].length
+            rest = match[2]
+            closing = rest.match?(/\A\s*\z/)
+
+            if closing && open_fences.last&.marker == marker && length >= open_fences.last.length
+              opening = open_fences.pop
+              fences << Fence.new(
+                line: line_number,
+                start: offset,
+                finish: offset + line.length,
+                marker: marker,
+                length: length,
+                language: opening.language
+              )
+              opening.close_line = line_number
+              opening.close_start = offset
+              opening.close_end = offset + line.length
+              offset += line.length
+              next
+            end
+
+            next if closing
+
+            opening = Fence.new(
+              line: line_number,
+              start: offset,
+              finish: offset + line.length,
+              marker: marker,
+              length: length,
+              language: rest.strip.split(/\s+/, 2).first
+            )
+            open_fences << opening
+            fences << opening
+          end
+          offset += line.length
+        end
+
+        completed = fences.select { |fence| fence.close_line }
+        completed.map do |opening|
+          next_fence = fences.map(&:start).select { |start| start > opening.close_end }.min
+          Block.new(
+            source: source,
+            open_line: opening.line,
+            close_line: opening.close_line,
+            language: opening.language,
+            body_start: opening.finish,
+            body_end: opening.close_start,
+            close_end: opening.close_end,
+            next_fence_start: next_fence
+          )
+        end
+      end
+
+      def format_output(output, newline: "\n")
+        body = output.to_s.gsub(/\r\n?/, "\n").chomp
+        body = body.gsub("\n", newline)
+        body.empty? ? "<output>#{newline}</output>" : "<output>#{newline}#{body}#{newline}</output>"
+      end
+    end
+  end
+end

data/lib/kward/model/client.rb

@@ -37,12 +37,12 @@ module Kward
       "lm_studio" => "http://127.0.0.1:1234/v1",
       "llama_cpp" => "http://127.0.0.1:8080/v1"
     }.freeze
-    AUTH_ERROR = "No OpenAI OAuth login found. Run `ruby lib/main.rb login`, or set OPENAI_ACCESS_TOKEN/OPENROUTER_API_KEY."
-    OPENROUTER_AUTH_ERROR = "No OpenRouter API key found. Set OPENROUTER_API_KEY or sign in with an API key."
-    OPENAI_API_AUTH_ERROR = "No OpenAI API key found. Set OPENAI_API_KEY or sign in with an API key."
-    AZURE_OPENAI_AUTH_ERROR = "No Azure OpenAI API key found. Set AZURE_OPENAI_API_KEY or sign in with an API key."
-    COPILOT_AUTH_ERROR = "No GitHub Copilot OAuth login found. Run `ruby lib/main.rb login github` or set COPILOT_GITHUB_TOKEN."
-    ANTHROPIC_AUTH_ERROR = "No Anthropic OAuth login found. Run `ruby lib/main.rb login anthropic`."
+    AUTH_ERROR = "No OpenAI OAuth login found. Run `kward login`, or set OPENAI_ACCESS_TOKEN or OPENROUTER_API_KEY."
+    OPENROUTER_AUTH_ERROR = "No OpenRouter API key found. Run `kward login openrouter`, or set OPENROUTER_API_KEY."
+    OPENAI_API_AUTH_ERROR = "No OpenAI API key found. Run `kward login`, or set OPENAI_API_KEY."
+    AZURE_OPENAI_AUTH_ERROR = "No Azure OpenAI API key found. Run `kward login`, or set AZURE_OPENAI_API_KEY."
+    COPILOT_AUTH_ERROR = "No GitHub Copilot OAuth login found. Run `kward login github`, or set COPILOT_GITHUB_TOKEN."
+    ANTHROPIC_AUTH_ERROR = "No Anthropic OAuth login found. Run `kward login anthropic`."
     DEFAULT_OPENAI_MODEL = ModelInfo::DEFAULT_OPENAI_MODEL
     DEFAULT_REASONING_EFFORT = ModelInfo::DEFAULT_REASONING_EFFORT
     RETRY_DELAYS = [1, 2].freeze
@@ -61,6 +61,8 @@ module Kward
       /(?:exceeded|reached).*(?:usage|quota|credit|budget|balance)/i
     ].freeze
 
+    AuthenticationError = Class.new(RuntimeError)
+
     RequestError = Class.new(StandardError) do
       attr_reader :provider, :code, :body
 
@@ -108,11 +110,12 @@ module Kward
       @local_models = nil
     end
 
-    def chat(messages, tools: [], on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil)
+    def chat(messages, tools: [], on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil, provider_required: false)
       cancellation&.raise_if_cancelled!
       requested_provider = provider
+      validate_required_provider!(requested_provider) if provider_required
       url, token, resolved_provider, account_id = credentials(provider: requested_provider)
-      if token.to_s.empty? && authentication_required?(resolved_provider) && !requested_provider.to_s.empty? && resolved_provider != "OpenAI"
+      if token.to_s.empty? && authentication_required?(resolved_provider) && !provider_required && !requested_provider.to_s.empty? && resolved_provider != "OpenAI"
         url, token, resolved_provider, account_id = credentials
         model = nil
         reasoning = nil
@@ -593,20 +596,22 @@ module Kward
     end
 
     def auth_error_for(provider)
-      case provider
-      when "Azure OpenAI"
-        AZURE_OPENAI_AUTH_ERROR
-      when "OpenAI"
-        OPENAI_API_AUTH_ERROR
-      when "OpenRouter"
-        OPENROUTER_AUTH_ERROR
-      when "Copilot"
-        COPILOT_AUTH_ERROR
-      when "Anthropic"
-        ANTHROPIC_AUTH_ERROR
-      else
-        AUTH_ERROR
-      end
+      message =
+        case provider
+        when "Azure OpenAI"
+          AZURE_OPENAI_AUTH_ERROR
+        when "OpenAI"
+          OPENAI_API_AUTH_ERROR
+        when "OpenRouter"
+          OPENROUTER_AUTH_ERROR
+        when "Copilot"
+          COPILOT_AUTH_ERROR
+        when "Anthropic"
+          ANTHROPIC_AUTH_ERROR
+        else
+          AUTH_ERROR
+        end
+      AuthenticationError.new(message)
     end
 
     def with_retries(provider, model, request_bytes: nil, on_retry: nil, cancellation: nil)
@@ -906,7 +911,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 +936,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
@@ -1079,6 +1068,13 @@ module Kward
       ModelInfo.reasoning_effort(config: @config, provider: provider)
     end
 
+    def validate_required_provider!(provider)
+      provider_id = provider.to_s.strip.downcase
+      return if ProviderCatalog.configuration_ids.include?(provider_id)
+
+      raise ArgumentError, "Unknown provider: #{provider}"
+    end
+
     def authentication_required?(provider)
       provider != "Local"
     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

data/lib/kward/model/provider_catalog.rb

@@ -71,9 +71,14 @@ module Kward
       Definition.new(id: "xai", name: "xAI", api_key_env: ["XAI_API_KEY"], protocol: "openai_chat", oauth_name: "xAI Grok"),
       Definition.new(id: "copilot", name: "GitHub Copilot", api_key_env: [], protocol: "copilot", oauth_name: "GitHub Copilot")
     ].freeze
+    CONFIGURATION_IDS = (["codex", "openai_api", "local"] + DEFINITIONS.map(&:id).reject { |id| id == "openai" }).freeze
 
     module_function
 
+    def configuration_ids
+      CONFIGURATION_IDS
+    end
+
     def all
       DEFINITIONS
     end

data/lib/kward/model/stream_parser.rb

@@ -347,7 +347,7 @@ module Kward
       when "response.content_part.added"
         codex_content_part_added(state, event["part"])
       when "response.output_text.delta", "response.refusal.delta"
-        codex_output_text_delta(state, event["delta"], on_assistant_delta: on_assistant_delta)
+        codex_output_text_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta)
       when "response.reasoning_summary_part.added"
         codex_reasoning_summary_part_added(state, event["part"])
       when "response.reasoning_summary_text.delta"
@@ -417,7 +417,7 @@ module Kward
       state[:current_text_content_part] = item["content"].last
     end
 
-    def codex_output_text_delta(state, delta, on_assistant_delta: nil)
+    def codex_output_text_delta(state, delta, on_reasoning_delta: nil, on_assistant_delta: nil)
       text = delta.to_s
       return if text.empty?
 
@@ -432,6 +432,9 @@ module Kward
         if codex_streamable_message_item?(item)
           on_assistant_delta&.call(text)
           state[:emitted_message_keys] << codex_item_key(item)
+        elsif codex_commentary_message_item?(item)
+          on_reasoning_delta&.call(text)
+          state[:emitted_message_keys] << codex_item_key(item)
         end
       end
       state[:raw_content] << text
@@ -647,10 +650,19 @@ module Kward
       case item["type"]
       when "message"
         text = text_from_codex_items([item])
-        return if text.empty? || !codex_streamable_message_item?(item)
+        return if text.empty?
 
-        state[:content] << text
         key = codex_item_key(item)
+        if codex_commentary_message_item?(item)
+          unless state[:emitted_message_keys].include?(key)
+            on_reasoning_delta&.call(text)
+            state[:emitted_message_keys] << key
+          end
+          return
+        end
+        return unless codex_streamable_message_item?(item)
+
+        state[:content] << text
         unless state[:emitted_message_keys].include?(key)
           on_assistant_delta&.call(text)
           state[:emitted_message_keys] << key
@@ -774,6 +786,10 @@ module Kward
       phase.empty? || phase == "final_answer"
     end
 
+    def codex_commentary_message_item?(item)
+      codex_message_phase(item) == "commentary"
+    end
+
     def codex_message_phase(item)
       item["phase"].to_s
     end

data/lib/kward/pan/index.html.erb

@@ -162,7 +162,7 @@
         <button class="icon-button" id="open-sessions" type="button" aria-label="Open sessions">☰</button>
         <div class="title-block">
           <div class="title-row"><span class="live-dot"></span><h1 id="conversation-title">New session</h1></div>
-          <div class="top-meta" id="session-meta">Secure LAN workspace</div>
+          <div class="top-meta" id="session-meta">Authenticated HTTP workspace</div>
         </div>
         <button class="text-button" id="capture-skill" type="button">Capture skill</button>
         <button class="text-button" id="rename-session" type="button">Rename</button>
@@ -176,7 +176,7 @@
       <div class="composer-shell">
         <form id="prompt-form">
           <div class="composer">
-            <textarea id="prompt" name="prompt" rows="1" autocomplete="off" enterkeyhint="send" aria-label="Prompt" placeholder="Give <%= ERB::Util.html_escape(@assistant_label) %> an order…"></textarea>
+            <textarea id="prompt" name="prompt" rows="1" autocomplete="off" enterkeyhint="send" aria-label="Prompt" placeholder="Ask <%= ERB::Util.html_escape(@assistant_label) %> to inspect, explain, or change code…"></textarea>
             <button class="send" id="send" type="submit" aria-label="Send prompt">↑</button>
           </div>
           <div class="composer-meta"><span id="status">Connecting…</span><span>Return to send · Shift Return for a new line</span></div>
@@ -437,7 +437,7 @@
       if (!activeSession) return;
       titleEl.textContent = activeSession.title || activeSession.name || 'New session';
       const details = [activeSession.model, activeSession.messageCount != null ? `${activeSession.messageCount} messages` : null].filter(Boolean);
-      sessionMeta.textContent = details.join(' · ') || 'Secure LAN workspace';
+      sessionMeta.textContent = details.join(' · ') || 'Authenticated HTTP workspace';
     }
 
     async function changeSession(action, values = {}) {