kward 0.73.1 → 0.75.0

data/lib/kward/hooks/manager.rb

@@ -0,0 +1,158 @@
+require_relative "../deep_copy"
+require_relative "audit_log"
+require_relative "catalog"
+require_relative "decision"
+require_relative "event"
+require_relative "matcher"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module Hooks
+    # Dispatches lifecycle events to registered hooks and combines decisions.
+    class Manager
+      Handler = Struct.new(:id, :event, :source, :order, :match, :callback, :failure_policy, keyword_init: true)
+      Result = Struct.new(:event, :decision, :decisions, :warnings, :messages, :payload, keyword_init: true) do
+        def allowed?
+          !decision.deny? && !decision.ask?
+        end
+
+        def denied?
+          decision.deny?
+        end
+
+        def approval_required?
+          decision.ask?
+        end
+      end
+
+      attr_reader :handlers
+      attr_writer :on_result
+
+      def initialize(audit_log: AuditLog.new, on_result: nil)
+        @handlers = []
+        @audit_log = audit_log
+        @on_result = on_result
+      end
+
+      def register(event, id: nil, source: nil, order: 100, match: nil, failure_policy: nil, &callback)
+        raise ArgumentError, "Hook requires an event name" if event.to_s.empty?
+        raise ArgumentError, "Hook requires a handler" unless callback
+
+        handler = Handler.new(
+          id: id || "#{source || "hook"}:#{event}:#{@handlers.length + 1}",
+          event: event.to_s,
+          source: source,
+          order: order.to_i,
+          match: Matcher.new(match),
+          callback: callback,
+          failure_policy: Catalog.failure_policy(event, failure_policy)
+        )
+        @handlers << handler
+        handler
+      end
+
+      def empty?
+        @handlers.empty?
+      end
+
+      def run(event, context: nil)
+        event = normalize_event(event)
+        decisions = []
+        warnings = []
+        messages = []
+        payload = DeepCopy.dup(event.payload)
+
+        handlers_for(event).each do |handler|
+          decision = call_handler(handler, event, context)
+          decisions << decision
+          warnings << decision.message if decision.warning? && decision.message
+          messages << decision.message if decision.message && !decision.warning?
+
+          if decision.modify?
+            modifications = Catalog.filter_modifications(event.name, decision.payload)
+            payload = DeepCopy.merge(payload, modifications)
+            event = event_with_payload(event, payload)
+          end
+
+          break if decision.deny?
+        end
+
+        final_decision = final_decision(decisions)
+        result = Result.new(
+          event: event,
+          decision: final_decision,
+          decisions: decisions,
+          warnings: warnings,
+          messages: messages,
+          payload: payload
+        )
+        @audit_log&.log_result(event: event, result: result)
+        @on_result&.call(event, result) unless decisions.empty?
+        result
+      end
+
+      private
+
+      def normalize_event(event)
+        return event if event.is_a?(Event)
+
+        Event.new(**event)
+      end
+
+      def handlers_for(event)
+        @handlers
+          .select { |handler| handler.event == event.name && handler.match.match?(event) }
+          .sort_by { |handler| [handler.order, handler.id.to_s] }
+      end
+
+      def call_handler(handler, event, context)
+        started_at = @audit_log&.monotonic_now
+        value = if handler.callback.arity == 1
+                  handler.callback.call(event)
+                else
+                  handler.callback.call(event, context)
+                end
+        Decision.normalize(value).tap do |decision|
+          log_handler(event, handler, decision, started_at)
+        end
+      rescue StandardError => e
+        Catalog.failure_decision(
+          handler.failure_policy,
+          "Hook #{handler.id} failed: #{e.message}",
+          metadata: { hook_id: handler.id, source: handler.source }
+        ).tap do |decision|
+          log_handler(event, handler, decision, started_at)
+        end
+      end
+
+      def log_handler(event, handler, decision, started_at)
+        @audit_log&.log_handler(
+          event: event,
+          handler: handler,
+          decision: decision,
+          duration_ms: started_at ? @audit_log.duration_ms(started_at) : nil
+        )
+      end
+
+      def final_decision(decisions)
+        decisions.find(&:deny?) || decisions.find(&:ask?) || decisions.reverse.find(&:modify?) || decisions.find(&:warning?) || Decision.allow
+      end
+
+      def event_with_payload(event, payload)
+        Event.new(
+          id: event.id,
+          name: event.name,
+          phase: event.phase,
+          timestamp: event.timestamp,
+          session: event.session,
+          turn: event.turn,
+          workspace: event.workspace,
+          frontend: event.frontend,
+          agent: event.agent,
+          payload: payload
+        )
+      end
+
+    end
+  end
+end

data/lib/kward/hooks/matcher.rb

@@ -0,0 +1,75 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module Hooks
+    # Matches lifecycle hook selectors against event payloads.
+    class Matcher
+      def initialize(match = nil)
+        @match = match || {}
+      end
+
+      def match?(event)
+        return true if @match.empty?
+
+        @match.all? { |key, expected| matches_key?(event, key.to_s, expected) }
+      end
+
+      private
+
+      def matches_key?(event, key, expected)
+        case key
+        when "event", "name"
+          matches_value?(event.name, expected)
+        when "phase"
+          matches_value?(event.phase, expected)
+        when "tool", "tool_name"
+          matches_value?(payload_value(event, "tool_name") || payload_value(event, "tool"), expected)
+        when "mcp_server", "server"
+          matches_value?(payload_value(event, "server_name") || payload_value(event, "mcp_server"), expected)
+        when "mcp_tool", "remote_name"
+          matches_value?(payload_value(event, "remote_name") || payload_value(event, "mcp_tool"), expected)
+        when "operation"
+          matches_value?(payload_value(event, "operation"), expected)
+        when "frontend"
+          matches_value?(event.frontend[:name] || event.frontend["name"], expected)
+        when "provider"
+          matches_value?(event.agent[:provider] || event.agent["provider"], expected)
+        when "model"
+          matches_value?(event.agent[:model] || event.agent["model"], expected)
+        when "path", "paths"
+          matches_path?(payload_paths(event), expected)
+        when "command_regex"
+          value = payload_value(event, "command").to_s
+          Array(expected).any? { |pattern| Regexp.new(pattern.to_s).match?(value) }
+        else
+          matches_value?(payload_value(event, key), expected)
+        end
+      end
+
+      def payload_value(event, key)
+        event.payload[key.to_sym] || event.payload[key]
+      end
+
+      def payload_paths(event)
+        values = []
+        values << payload_value(event, "path")
+        values.concat(Array(payload_value(event, "paths")))
+        Array(payload_value(event, "files")).each do |file|
+          values << (file[:path] || file["path"]) if file.respond_to?(:[])
+        end
+        values.compact.map(&:to_s)
+      end
+
+      def matches_path?(paths, expected)
+        patterns = Array(expected).map(&:to_s)
+        paths.any? do |path|
+          patterns.any? { |pattern| File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+        end
+      end
+
+      def matches_value?(actual, expected)
+        expected_values = Array(expected).map(&:to_s)
+        expected_values.include?(actual.to_s)
+      end
+    end
+  end
+end

data/lib/kward/hooks.rb

@@ -0,0 +1,16 @@
+require_relative "hooks/audit_log"
+require_relative "hooks/catalog"
+require_relative "hooks/decision"
+require_relative "hooks/event"
+require_relative "hooks/matcher"
+require_relative "hooks/manager"
+require_relative "hooks/command_handler"
+require_relative "hooks/http_handler"
+require_relative "hooks/config_loader"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Lifecycle hook primitives and dispatch helpers.
+  module Hooks
+  end
+end

data/lib/kward/markdown_transcript.rb

@@ -1,4 +1,5 @@
 require_relative "message_access"
+require_relative "message_text"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -37,10 +38,10 @@ module Kward
     end
 
     def message_display_text(message)
-      display_content = MessageAccess.value(message, :display_content) || MessageAccess.value(message, :displayContent)
-      return display_content.to_s unless display_content.nil?
+      return MessageText.full_text(message) unless MessageAccess.display_content(message).nil?
 
-      markdown_content(MessageAccess.content(message))
+      content = MessageAccess.content(message)
+      content.is_a?(Array) ? markdown_content(content) : MessageText.full_text(message)
     end
 
     def markdown_content(content)

data/lib/kward/mcp/client.rb

@@ -0,0 +1,56 @@
+require_relative "stdio_transport"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model Context Protocol client support.
+  module MCP
+    PROTOCOL_VERSION = "2025-11-25"
+
+    # Minimal MCP client for discovering and invoking server tools.
+    class Client
+      attr_reader :name, :transport
+
+      def initialize(name:, transport:)
+        @name = name.to_s
+        @transport = transport
+        @initialized = false
+      end
+
+      def initialize!
+        return if @initialized
+
+        @transport.request("initialize", initialize_params)
+        @transport.notify("notifications/initialized")
+        @initialized = true
+      end
+
+      def list_tools
+        initialize!
+        result = @transport.request("tools/list", {})
+        Array(result["tools"] || result[:tools])
+      end
+
+      def call_tool(name, arguments = {})
+        initialize!
+        @transport.request("tools/call", { name: name, arguments: arguments || {} })
+      end
+
+      def close
+        @transport.close
+      end
+
+      private
+
+      def initialize_params
+        {
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: {
+            name: "kward",
+            version: Kward.const_defined?(:VERSION) ? Kward::VERSION : "0.0.0"
+          }
+        }
+      end
+    end
+  end
+end

data/lib/kward/mcp/server_config.rb

@@ -0,0 +1,59 @@
+require_relative "../config_files"
+require_relative "client"
+require_relative "stdio_transport"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model Context Protocol client support.
+  module MCP
+    # Builds MCP clients from Kward configuration.
+    module ServerConfig
+      module_function
+
+      def clients_from_config(config)
+        configured_servers(config).filter_map do |name, settings|
+          client_from_settings(name, settings)
+        end
+      end
+
+      def configured_servers(config)
+        ConfigFiles.mcp_servers(config).select do |_name, settings|
+          settings.is_a?(Hash) && settings["enabled"] != false
+        end
+      end
+
+      def client_from_settings(name, settings)
+        return nil unless settings.is_a?(Hash)
+        return nil if settings["enabled"] == false
+
+        command = settings["command"].to_s
+        return nil if command.empty?
+
+        Client.new(
+          name: name,
+          transport: StdioTransport.new(
+            command: command,
+            args: settings["args"] || [],
+            env: normalized_env(settings["env"]),
+            timeout_seconds: positive_number(settings["timeout_seconds"] || settings["timeoutSeconds"])
+          )
+        )
+      end
+
+      def normalized_env(value)
+        return {} unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(key, item), env|
+          env[key.to_s] = item.to_s
+        end
+      end
+
+      def positive_number(value)
+        number = value.to_f
+        number.positive? ? number : nil
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/kward/mcp/stdio_transport.rb

@@ -0,0 +1,112 @@
+require "json"
+require "open3"
+require "timeout"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model Context Protocol client support.
+  module MCP
+    # JSON-RPC transport for local MCP servers that communicate over stdio.
+    class StdioTransport
+      DEFAULT_TIMEOUT_SECONDS = 10
+
+      attr_reader :command
+
+      def initialize(command:, args: [], env: {}, timeout_seconds: DEFAULT_TIMEOUT_SECONDS)
+        @command = command.to_s
+        @args = Array(args).map(&:to_s)
+        @env = env || {}
+        @timeout_seconds = timeout_seconds || DEFAULT_TIMEOUT_SECONDS
+        @mutex = Mutex.new
+        @started = false
+      end
+
+      def request(method, params = nil)
+        @mutex.synchronize do
+          start
+          id = next_id
+          write_message({ jsonrpc: "2.0", id: id, method: method, params: params }.compact)
+          read_response(id)
+        end
+      end
+
+      def notify(method, params = nil)
+        @mutex.synchronize do
+          start
+          write_message({ jsonrpc: "2.0", method: method, params: params }.compact)
+        end
+      end
+
+      def close
+        @stdin&.close unless @stdin&.closed?
+        @stdout&.close unless @stdout&.closed?
+        @stderr&.close unless @stderr&.closed?
+        @stderr_thread&.kill
+        terminate_process
+      rescue IOError
+        nil
+      end
+
+      private
+
+      def terminate_process
+        return unless @wait_thread&.alive?
+
+        Process.kill("TERM", @wait_thread.pid)
+        @wait_thread.join(1)
+        Process.kill("KILL", @wait_thread.pid) if @wait_thread.alive?
+      rescue Errno::ESRCH, IOError
+        nil
+      end
+
+      def start
+        return if @started
+        raise ArgumentError, "MCP server command is required" if @command.empty?
+
+        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(@env, @command, *@args)
+        @stderr_thread = Thread.new do
+          @stderr.each_line { |_line| }
+        rescue IOError
+          nil
+        end
+        @started = true
+      rescue SystemCallError => e
+        raise "Failed to start MCP server #{@command}: #{e.message}"
+      end
+
+      def next_id
+        @next_id ||= 0
+        @next_id += 1
+      end
+
+      def write_message(message)
+        @stdin.write(JSON.generate(message))
+        @stdin.write("\n")
+        @stdin.flush
+      rescue IOError, Errno::EPIPE => e
+        raise "MCP server #{@command} is not accepting requests: #{e.message}"
+      end
+
+      def read_response(expected_id)
+        Timeout.timeout(@timeout_seconds) do
+          loop do
+            line = @stdout.gets
+            raise "MCP server #{@command} closed stdout" unless line
+
+            message = JSON.parse(line)
+            next unless message["id"] == expected_id
+
+            error = message["error"]
+            raise "MCP request failed: #{error["message"] || error.inspect}" if error
+
+            return message["result"] || {}
+          end
+        end
+      rescue JSON::ParserError
+        raise "MCP server #{@command} returned invalid JSON"
+      rescue Timeout::Error
+        raise "MCP server #{@command} did not respond within #{@timeout_seconds} seconds"
+      end
+    end
+  end
+end

data/lib/kward/memory/turn_context.rb

@@ -0,0 +1,19 @@
+require_relative "manager"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module Memory
+    # Applies retrieved memory context to a conversation before a model turn.
+    module TurnContext
+      module_function
+
+      def apply(conversation:, input:, manager: Manager.new)
+        retrieval = manager.retrieve_relevant(input: input, workspace_root: conversation.workspace_root)
+        conversation.last_memory_retrieval = retrieval
+        conversation.memory_context = manager.memory_block(retrieval)
+        conversation.refresh_system_message!
+        retrieval
+      end
+    end
+  end
+end

data/lib/kward/message_access.rb

@@ -5,8 +5,8 @@ module Kward
   # Kward stores transcript entries as plain hashes because model payloads,
   # JSONL sessions, plugins, and RPC normalizers all need to pass them around
   # without framework objects. Restored sessions may contain either symbol keys,
-  # string keys, or Tauren-style camelCase aliases. `MessageAccess` centralizes
-  # those lookup rules so callers do not grow one-off compatibility branches.
+  # string keys, or camelCase aliases. `MessageAccess` centralizes those lookup
+  # rules so callers do not grow one-off compatibility branches.
   module MessageAccess
     module_function
 

data/lib/kward/message_text.rb

@@ -28,6 +28,20 @@ module Kward
       content_text(MessageAccess.content(message)).strip
     end
 
+    # Returns compact one-line text for session tree and list previews.
+    #
+    # @param message [Hash] persisted conversation message
+    # @param length [Integer] maximum preview length
+    # @return [String] whitespace-normalized text, truncated with ellipsis
+    def preview(message, length: 120)
+      text = if MessageAccess.role(message) == "compactionSummary"
+               MessageAccess.summary(message).to_s
+             else
+               full_text(message)
+             end
+      truncate_preview(text, length: length)
+    end
+
     # Converts message content into plain text without applying display-content
     # overrides.
     #
@@ -41,5 +55,10 @@ module Kward
         content.to_s
       end
     end
+
+    def truncate_preview(text, length: 120)
+      normalized = text.to_s.gsub(/\s+/, " ").strip
+      normalized.length > length ? "#{normalized.slice(0, length - 3)}..." : normalized
+    end
   end
 end

data/lib/kward/model/client.rb

@@ -8,6 +8,7 @@ require_relative "../cancellation"
 require_relative "../config_files"
 require_relative "../openrouter_model_cache"
 require_relative "context_overflow"
+require_relative "copilot_models"
 require_relative "model_info"
 require_relative "payloads"
 require_relative "../telemetry/logger"
@@ -227,8 +228,8 @@ module Kward
     end
 
     # Projects messages/tools into the provider-specific context shape without sending it.
-    def current_context_parts(messages, tools)
-      build_context_parts(current_provider, messages, tools)
+    def current_context_parts(messages, tools, provider: current_provider, model: nil)
+      build_context_parts(ModelInfo.provider_label(provider), messages, tools, model: model)
     end
 
     # Returns whether the active provider can accept steering while a turn is streaming.
@@ -525,30 +526,15 @@ module Kward
       live_models = fetch_copilot_models
       return static_copilot_model_choices if live_models.empty?
 
-      supported_copilot_model_choices(live_models)
+      CopilotModels.supported_choices(live_models)
     end
 
     def static_copilot_model_choices
-      supported_copilot_model_choices(ModelInfo::COPILOT_MODEL_CHOICES)
-    end
-
-    def supported_copilot_model_choices(choices)
-      choices.select { |model| copilot_supported_model?(model) }.uniq
+      CopilotModels.supported_choices(ModelInfo::COPILOT_MODEL_CHOICES)
     end
 
     def resolved_copilot_chat_model(configured_model)
-      choices = fetch_copilot_models
-      return configured_model if choices.empty? || choices.include?(configured_model)
-
-      supported = choices.find { |model| copilot_supported_model?(model) }
-      raise "No Copilot models supported by Kward are available for this account. Kward currently supports Copilot GPT-5 Responses and Gemini/GPT-4.1 chat models." unless supported
-
-      supported
-    end
-
-    def copilot_supported_model?(model)
-      text = model.to_s
-      copilot_responses_model?(text) || text.match?(/\A(?:gemini-|gpt-4\.1|oswe-)/)
+      CopilotModels.resolved_chat_model(configured_model, fetch_copilot_models)
     end
 
     def fetch_copilot_models
@@ -566,33 +552,11 @@ module Kward
       response = Net::HTTP.start(url.hostname, url.port, use_ssl: true) { |http| http.request(request) }
       return [] unless response.is_a?(Net::HTTPSuccess)
 
-      @copilot_models = parse_copilot_models(response.body)
+      @copilot_models = CopilotModels.parse(response.body)
     rescue StandardError
       []
     end
 
-    def parse_copilot_models(body)
-      model_catalog_entries(body).filter_map do |entry|
-        copilot_model_id(entry)
-      end.uniq
-    rescue JSON::ParserError
-      []
-    end
-
-    def model_catalog_entries(body)
-      data = JSON.parse(body.to_s)
-      entries = data.is_a?(Hash) ? data["data"] || data["models"] || data["items"] || [] : data
-      Array(entries)
-    end
-
-    def copilot_model_id(entry)
-      return entry.to_s.strip unless entry.is_a?(Hash)
-      return nil if entry.key?("model_picker_enabled") && entry["model_picker_enabled"] == false
-
-      id = entry["id"] || entry["model"] || entry["name"]
-      id.to_s.strip unless id.to_s.strip.empty?
-    end
-
     def copilot_responses_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
       parts = build_context_parts("CopilotResponses", messages, tools, model: model)
       payload = {
@@ -718,11 +682,11 @@ module Kward
     end
 
     def parse_codex_sse(body, on_reasoning_delta: nil, on_assistant_delta: nil)
-      ModelStreamParser.parse_codex_sse(body, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
+      ModelStreamParser.parse_codex_sse(body, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
     end
 
     def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil)
-      ModelStreamParser.parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
+      ModelStreamParser.parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
     end
 
     def parse_anthropic_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil)
@@ -871,6 +835,10 @@ module Kward
       ConfigFiles.config_value(@config, *keys)
     end
 
+    def codex_show_raw_reasoning?
+      @config["codex_show_raw_reasoning"] == true
+    end
+
     def load_config
       ConfigFiles.read_config(@config_path)
     end