kward 0.79.0 → 0.80.1

data/lib/kward/skills/registry.rb

@@ -14,7 +14,7 @@ module Kward
     class Registry
       SkillSource = Struct.new(:root, :label, :scope, :precedence, keyword_init: true)
 
-      def initialize(config_dir:, workspace_root:, project_skills_trusted:, skill_class:, max_file_bytes:, markdown_parser:, inside_directory:)
+      def initialize(config_dir:, workspace_root:, project_skills_trusted:, skill_class:, max_file_bytes:, markdown_parser:, inside_directory:, warning_sink: nil)
         @config_dir = config_dir
         @workspace_root = workspace_root
         @project_skills_trusted = project_skills_trusted
@@ -22,6 +22,7 @@ module Kward
         @max_file_bytes = max_file_bytes
         @markdown_parser = markdown_parser
         @inside_directory = inside_directory
+        @warning_sink = warning_sink
       end
 
       # Returns discovered, validated skills in precedence order.
@@ -36,7 +37,7 @@ module Kward
             next unless skill
 
             if seen[skill.name]
-              warn "Warning: skipping duplicate Kward skill #{skill.name.inspect}: #{path}"
+              emit_warning "Warning: skipping duplicate Kward skill #{skill.name.inspect}: #{path}"
               next
             end
 
@@ -45,7 +46,7 @@ module Kward
           end
         end
       rescue StandardError => e
-        warn "Warning: skipping Kward skills: #{e.message}"
+        emit_warning "Warning: skipping Kward skills: #{e.message}"
         []
       end
 
@@ -99,13 +100,13 @@ module Kward
       def scan_source(source)
         return [] unless Dir.exist?(source.root)
         if source.scope == :project && !@project_skills_trusted
-          warn "Warning: skipping #{source.label} in #{source.root}: project skills are not trusted"
+          emit_warning "Warning: skipping #{source.label} in #{source.root}: project skills are not trusted"
           return []
         end
 
         Dir.glob(File.join(source.root, "*", "SKILL.md")).sort
       rescue StandardError => e
-        warn "Warning: skipping #{source.label} in #{source.root}: #{e.message}"
+        emit_warning "Warning: skipping #{source.label} in #{source.root}: #{e.message}"
         []
       end
 
@@ -151,12 +152,12 @@ module Kward
         return warn_skip(path, "missing description") if description.empty?
         return warn_skip(path, "description exceeds 1024 characters") if description.length > 1024
 
-        warn "Warning: Kward skill #{path}: name does not match parent directory" if name != File.basename(File.dirname(path))
-        warn "Warning: Kward skill #{path}: name exceeds 64 characters" if name.length > 64
-        warn "Warning: Kward skill #{path}: name contains invalid characters" unless valid_name?(name)
+        emit_warning "Warning: Kward skill #{path}: name does not match parent directory" if name != File.basename(File.dirname(path))
+        emit_warning "Warning: Kward skill #{path}: name exceeds 64 characters" if name.length > 64
+        emit_warning "Warning: Kward skill #{path}: name contains invalid characters" unless valid_name?(name)
 
         compatibility = optional_text(frontmatter["compatibility"])
-        warn "Warning: Kward skill #{path}: compatibility exceeds 500 characters" if compatibility && compatibility.length > 500
+        emit_warning "Warning: Kward skill #{path}: compatibility exceeds 500 characters" if compatibility && compatibility.length > 500
 
         @skill_class.new(
           name: name,
@@ -169,7 +170,7 @@ module Kward
           allowed_tools: optional_text(frontmatter["allowed-tools"])
         )
       rescue StandardError => e
-        warn "Warning: skipping Kward skill #{path}: #{e.message}"
+        emit_warning "Warning: skipping Kward skill #{path}: #{e.message}"
         nil
       end
 
@@ -183,9 +184,13 @@ module Kward
       end
 
       def warn_skip(path, reason)
-        warn "Warning: skipping Kward skill #{path}: #{reason}"
+        emit_warning "Warning: skipping Kward skill #{path}: #{reason}"
         nil
       end
+
+      def emit_warning(message)
+        @warning_sink ? @warning_sink.call(message) : warn(message)
+      end
     end
   end
 end

data/lib/kward/tab_driver.rb

@@ -3,11 +3,12 @@ module Kward
   # Adapts a session-backed agent to the tab runtime interface. Plugin tab
   # drivers implement the same small surface without becoming Kward sessions.
   class SessionTabDriver
-    attr_reader :session, :agent
+    attr_reader :session, :agent, :worktree
 
-    def initialize(session:, agent:)
+    def initialize(session:, agent:, worktree: nil)
       @session = session
       @agent = agent
+      @worktree = worktree
     end
 
     def messages
@@ -26,7 +27,9 @@ module Kward
     end
 
     def descriptor
-      { "kind" => "session", "session_path" => session.path }
+      descriptor = { "kind" => "session", "session_path" => session.path }
+      descriptor["worktree"] = worktree.descriptor if worktree
+      descriptor
     end
 
     def session?

data/lib/kward/telemetry/logger.rb

@@ -20,13 +20,14 @@ module Kward
     DEFAULT_MAX_BYTES = 10 * 1024 * 1024
 
     # Creates an object for telemetry event logging.
-    def initialize(config_path: ConfigFiles.config_path, log_dir: nil, max_bytes: DEFAULT_MAX_BYTES, clock: Time, monotonic_clock: Process, error_output: $stderr)
+    def initialize(config_path: ConfigFiles.config_path, log_dir: nil, max_bytes: DEFAULT_MAX_BYTES, clock: Time, monotonic_clock: Process, error_output: $stderr, warning_sink: nil)
       @config_path = config_path
       @log_dir = log_dir
       @max_bytes = max_bytes.to_i.positive? ? max_bytes.to_i : DEFAULT_MAX_BYTES
       @clock = clock
       @monotonic_clock = monotonic_clock
       @error_output = error_output
+      @warning_sink = warning_sink
       @mutex = Mutex.new
       @warned = false
     end
@@ -192,7 +193,9 @@ module Kward
       return if @warned
 
       @warned = true
-      @error_output&.puts("Warning: telemetry logging failed: #{error.message}")
+      message = "Warning: telemetry logging failed: #{error.message}"
+      sink = @warning_sink || ConfigFiles.warning_sink
+      sink ? sink.call(message) : @error_output&.puts(message)
     rescue StandardError
       nil
     end

data/lib/kward/tools/git_commit.rb

@@ -0,0 +1,39 @@
+require_relative "base"
+
+# Namespace for model-callable tool wrappers.
+module Kward
+  module Tools
+    # Tool wrapper for the trusted host-side Git commit operation.
+    class GitCommit < Base
+      def initialize(committer:)
+        @committer = committer
+        super(
+          "git_commit",
+          "Stage and commit changes in the active worktree. Omit paths to include all current changes.",
+          properties: {
+            message: { type: "string", description: "Commit message." },
+            paths: { type: "array", items: { type: "string" }, description: "Optional workspace-relative paths to include." }
+          },
+          required: ["message"]
+        )
+      end
+
+      def call(args, _conversation, cancellation: nil)
+        cancellation&.raise_if_cancelled!
+        message = argument(args, :message, "").to_s
+        paths = argument(args, :paths, nil)
+        return "Error: commit message is required" if message.strip.empty?
+        return "Error: paths must be an array" unless paths.nil? || paths.is_a?(Array)
+        return "Error: paths must contain strings" if paths && paths.any? { |path| !path.is_a?(String) }
+
+        paths = nil if paths&.empty?
+        result = @committer.call(message: message, paths: paths)
+        output = result[:output].to_s.strip
+        return "Git commit succeeded\n#{output}" if result[:success]
+
+        failure = output.empty? ? "Git commit failed." : "Git commit failed.\n#{output}"
+        "Error: #{failure}"
+      end
+    end
+  end
+end

data/lib/kward/tools/registry.rb

@@ -8,6 +8,7 @@ require_relative "context_for_task"
 require_relative "edit_file"
 require_relative "fetch_content"
 require_relative "fetch_raw"
+require_relative "git_commit"
 require_relative "list_directory"
 require_relative "mcp_tool"
 require_relative "read_file"
@@ -78,7 +79,7 @@ module Kward
     # @param web_search_enabled [Boolean, nil] override for web search exposure
     # @param skills [Array<ConfigFiles::Skill>, nil] override discovered skills
     # @param ask_user_question_enabled [Boolean, nil] override question exposure
-    def initialize(workspace: Workspace.new, prompt: nil, web_search: WebSearch.new, web_fetch: WebFetch.new, code_search: CodeSearch.new, web_search_enabled: nil, skills: nil, ask_user_question_enabled: nil, allowed_tool_names: nil, tool_output_compactor: ToolOutputCompactor.new, telemetry_logger: TelemetryLogger.new, context_budget_meter: nil, mcp_clients: nil, tool_approval: nil, approval_for_allowed_tools: false, permission_policy: nil, hook_manager: nil, hook_context: nil)
+    def initialize(workspace: Workspace.new, prompt: nil, web_search: WebSearch.new, web_fetch: WebFetch.new, code_search: CodeSearch.new, web_search_enabled: nil, skills: nil, ask_user_question_enabled: nil, allowed_tool_names: nil, tool_output_compactor: ToolOutputCompactor.new, telemetry_logger: TelemetryLogger.new, context_budget_meter: nil, mcp_clients: nil, tool_approval: nil, approval_for_allowed_tools: false, permission_policy: nil, hook_manager: nil, hook_context: nil, git_committer: nil)
       @workspace = workspace
       @prompt = prompt
       @web_search = web_search
@@ -96,6 +97,7 @@ module Kward
       @permission_policy = permission_policy || Permissions::Policy.from_config(ConfigFiles.read_config)
       @hook_manager = hook_manager
       @hook_context = hook_context
+      @git_committer = git_committer
       @mcp_clients = if mcp_clients
                        mcp_clients
                      elsif @allowed_tool_names
@@ -484,6 +486,7 @@ module Kward
 
     def build_schema_tools
       tools = @tools.values_at(*CORE_TOOL_NAMES)
+      tools << @tools["git_commit"] if @tools["git_commit"]
       tools.concat(@tools.values_at("web_search", "fetch_content", "fetch_raw")) if web_search_available?
       tools.concat(@tools.values.select { |tool| tool.is_a?(Tools::MCPTool) })
       tools << @tools["read_skill"] if skills_available?
@@ -492,7 +495,9 @@ module Kward
     end
 
     def all_tools
-      core_tools + [
+      tools = core_tools
+      tools << Tools::GitCommit.new(committer: @git_committer) if @git_committer
+      tools + [
         Tools::WebSearch.new(web_search: @web_search),
         Tools::FetchContent.new(web_fetch: @web_fetch),
         Tools::FetchRaw.new(web_fetch: @web_fetch),

data/lib/kward/tools/tool_call.rb

@@ -24,6 +24,7 @@ module Kward
       "web_search" => "web_search",
       "fetch_content" => "fetch_content",
       "fetch_raw" => "fetch_raw",
+      "git_commit" => "git_commit",
       "read_skill" => "read_skill",
       "ask_user_question" => "ask_user_question"
     }.freeze

data/lib/kward/transport/gateway.rb

@@ -0,0 +1,253 @@
+require "base64"
+require "digest"
+require "thread"
+require_relative "../deep_copy"
+require_relative "store"
+
+module Kward
+  module Transport
+    # Adapts the existing session manager to the transport host contract.
+    #
+    # The adapter deliberately uses the manager's public session and turn
+    # methods. It can be replaced by a frontend-neutral runtime gateway later
+    # without changing transport plugins.
+    class Gateway
+      POLL_INTERVAL = 0.05
+      TERMINAL_STATUSES = %w[completed canceled failed].freeze
+
+      def initialize(session_manager:, transport_id:, storage: nil, poll_interval: POLL_INTERVAL)
+        @session_manager = session_manager
+        @transport_id = transport_id.to_s
+        @storage = storage || Store.new(@transport_id)
+        @poll_interval = poll_interval
+        @subscriptions = []
+        @interaction_subscribers = []
+        @mutex = Mutex.new
+        @session_manager.subscribe_events { |method, payload| handle_runtime_event(method, payload) } if @session_manager.respond_to?(:subscribe_events)
+      end
+
+      def resolve_transport_session(transport_id:, conversation:, actor:, workspace_root: nil, name: nil, execution_profile: nil)
+        raise ArgumentError, "transport id does not match gateway" unless transport_id.to_s == @transport_id
+        if conversation.respond_to?(:transport_id) && conversation.transport_id.to_s != @transport_id
+          raise ArgumentError, "conversation transport does not match gateway"
+        end
+
+        binding_key = binding_key_for(conversation)
+        binding = @storage.get(binding_key)
+        session = if binding
+                     resume_bound_session(binding, execution_profile: execution_profile)
+                   else
+                     @session_manager.create_session(workspace_root: workspace_root || Dir.pwd, name: name, **execution_profile_arguments(execution_profile))
+                   end
+        persist_binding(binding_key, session)
+        session_handle(session)
+      end
+
+      def start_transport_turn(session_id:, input:, attachments: [], options: {}, streaming_behavior: nil, execution_profile: nil)
+        payload = @session_manager.start_turn(
+          session_id: session_id,
+          input: input,
+          attachments: normalize_attachments(attachments, execution_profile: execution_profile),
+          options: profile_options(options, execution_profile),
+          streaming_behavior: streaming_behavior,
+          execution_profile: execution_profile
+        )
+        { id: payload.fetch(:id), session_id: payload.fetch(:sessionId) }
+      end
+
+      def transport_transcript(session_id:)
+        @session_manager.transcript(session_id: session_id)
+      end
+
+      def transport_turn_events(turn_id:, after: nil)
+        payload = @session_manager.turn_events(turn_id: turn_id, after_sequence: after.to_i)
+        Array(payload[:events]).map { |event| normalize_event(event) }
+      end
+
+      def transport_turn_status(turn_id:)
+        @session_manager.turn_status(turn_id: turn_id)
+      end
+
+      def cancel_transport_turn(turn_id:)
+        @session_manager.cancel_turn(turn_id: turn_id)
+      end
+
+      def answer_transport_interaction(session_id:, request_id:, answer:)
+        if answer == true || answer == false
+          @session_manager.answer_tool_approval(
+            session_id: session_id,
+            approval_request_id: request_id,
+            approved: answer
+          )
+        else
+          answers = answer.is_a?(Array) ? answer : [{ question: request_id, answer: answer.to_s }]
+          @session_manager.answer_question(
+            session_id: session_id,
+            question_request_id: request_id,
+            answers: answers
+          )
+        end
+      end
+
+      def subscribe_transport_interactions(&block)
+        raise ArgumentError, "interaction subscription requires a block" unless block
+
+        @mutex.synchronize { @interaction_subscribers << block }
+        block
+      end
+
+      def subscribe_transport_turn(turn_id:, after: nil)
+        cursor = after.to_i
+        thread = Thread.new do
+          loop do
+            events = transport_turn_events(turn_id: turn_id, after: cursor)
+            events.each do |event|
+              cursor = event.sequence
+              yield event
+            end
+            status = transport_turn_status(turn_id: turn_id)
+            break if TERMINAL_STATUSES.include?(status[:status].to_s)
+
+            sleep @poll_interval
+          end
+        rescue StandardError
+          nil
+        end
+        @mutex.synchronize { @subscriptions << thread }
+        thread
+      end
+
+      def shutdown
+        subscriptions = @mutex.synchronize do
+          current = @subscriptions
+          @subscriptions = []
+          @interaction_subscribers = []
+          current
+        end
+        subscriptions.each(&:kill)
+        subscriptions.each(&:join)
+        nil
+      end
+
+      private
+
+      def resume_bound_session(binding, execution_profile: nil)
+        @session_manager.resume_session(
+          path: binding.fetch("path"),
+          workspace_root: binding.fetch("workspace_root"),
+          include_transcript: false,
+          **execution_profile_arguments(execution_profile)
+        )
+      rescue StandardError
+        @session_manager.create_session(workspace_root: binding.fetch("workspace_root"), **execution_profile_arguments(execution_profile))
+      end
+
+      def execution_profile_arguments(profile)
+        profile ? { execution_profile: profile } : {}
+      end
+
+      def persist_binding(key, session)
+        @storage.put(key, {
+          "path" => session.fetch(:path),
+          "workspace_root" => session.fetch(:workspaceRoot)
+        })
+      end
+
+      def session_handle(session)
+        Host::SessionHandle.new(
+          id: session.fetch(:id),
+          workspace_root: session.fetch(:workspaceRoot),
+          name: session[:name]
+        )
+      end
+
+      def binding_key_for(conversation)
+        external_id = conversation.respond_to?(:external_id) ? conversation.external_id : conversation.to_s
+        digest = Digest::SHA256.hexdigest("#{@transport_id}\0#{external_id}")
+        "binding:#{digest}"
+      end
+
+      def handle_runtime_event(method, payload)
+        request = case method
+                  when "ui/question"
+                    questions = Array(payload[:questions] || payload["questions"])
+                    Transport.interaction_request(
+                      id: payload[:questionRequestId] || payload["questionRequestId"],
+                      session_id: payload[:sessionId] || payload["sessionId"],
+                      turn_id: payload[:turnId] || payload["turnId"] || "unknown",
+                      kind: :question,
+                      prompt: questions.map { |question| question[:question] || question["question"] }.join("\\n"),
+                      choices: questions
+                    )
+                  when "tool/approvalRequested"
+                    Transport.interaction_request(
+                      id: payload[:approvalRequestId] || payload["approvalRequestId"],
+                      session_id: payload[:sessionId] || payload["sessionId"],
+                      turn_id: payload[:turnId] || payload["turnId"] || "unknown",
+                      kind: :tool_approval,
+                      prompt: "Allow #{payload[:toolName] || payload["toolName"]}?",
+                      choices: [{ id: "approve", label: "Approve" }, { id: "deny", label: "Deny" }],
+                      metadata: { tool_call_id: payload[:toolCallId] || payload["toolCallId"], args: payload[:args] || payload["args"] }
+                    )
+                  end
+        return unless request
+
+        subscribers = @mutex.synchronize { @interaction_subscribers.dup }
+        subscribers.each do |subscriber|
+          begin
+            subscriber.call(request)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      def profile_options(options, profile)
+        return options unless profile
+
+        options = options.dup
+        case profile.tool_mode
+        when :none
+          options.delete("disabledTools")
+          options.delete(:disabled_tools)
+          options["allowedTools"] = []
+        when :allowlist
+          options.delete("disabledTools")
+          options.delete(:disabled_tools)
+          options["allowedTools"] = profile.allowed_tools
+        end
+        options["approvalMode"] = "none" if profile.approval_mode == :deny
+        options["approvalMode"] = "ask" if profile.approval_mode == :ask
+        options
+      end
+
+      def normalize_attachments(attachments, execution_profile: nil)
+        if execution_profile && !execution_profile.attachments && !Array(attachments).empty?
+          raise ArgumentError, "transport execution profile does not allow attachments"
+        end
+
+        Array(attachments).map do |attachment|
+          raise ArgumentError, "transport attachment must be a Transport::Attachment" unless attachment.is_a?(Attachment)
+          raise ArgumentError, "transport attachment URLs are not supported by the session gateway" if attachment.url
+
+          {
+            type: "image",
+            data: Base64.strict_encode64(attachment.data),
+            mimeType: attachment.mime_type,
+            name: attachment.name
+          }.compact
+        end
+      end
+
+      def normalize_event(event)
+        Transport.turn_event(
+          type: event.fetch(:type),
+          session_id: event.fetch(:sessionId),
+          turn_id: event.fetch(:turnId),
+          sequence: event.fetch(:sequence),
+          payload: event.fetch(:payload, {})
+        )
+      end
+    end
+  end
+end