kward 0.73.0 → 0.74.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3b7a272f3d5171660fc2669a486830e334910cfef50af203b1eeedb989b6289
-  data.tar.gz: 3fb9b4ede65361609b6a1c594431d20136bb83c57e205e4b1b32332db75b2fbb
+  metadata.gz: b2f648e16f1d5c7187e428b30ecc2d5945f067c5decf98d1db46c51e1974a7d6
+  data.tar.gz: 5acbd39bd18701659c3699a80f6a660ae5bc85c8366083ee7aa3ec184dc93706
 SHA512:
-  metadata.gz: 9dec61bbf302b69eb5501a130c29d8104b342266cac1489f53608051db1cb03fb44a5b3d47388f43e2f271673f1ba2b4744637dc108701d13a37abd322913657
-  data.tar.gz: 5d057f370c989e973b2cd2bbef8464932251f7b2ffcddcfff6c86d3ecb28db4c5a1241e3eda1f5fa3b7f460cddbd7938dde6396e3335d6bbe9fb1b131d81f9a4
+  metadata.gz: 92de6ca9d486d9bc95d6c36d5bffa2bc591ad18b9dbf499aba14dc349c6f6f8492869b78788e7370a38b0e90067326a0678c0e3efb1a552b12604ab8db55d15d
+  data.tar.gz: 97f901a2f5992b34d6e3a75d92137518e6b16471ae66b73455cbbccfba740a480045271cac670d82d2920ceb61a48c4ecd2b83ae3de7d97b8bdecb8b284e658c

data/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to Kward will be documented in this file.
 
 ## [Unreleased]
 
+## [0.74.0] - 2026-06-30
+
+### Added
+
+- Added more Vim-compatible Vibe editor bindings, including `Y`, `>>`/`<<`, `~`, `g_`, `|`, `W`/`E`/`B`, `ge`/`gE`, case operators, `gJ`, counted `%`, previous-change mark jumps, jump-list navigation, and linewise paste semantics.
+- Added local stdio MCP server support through `mcpServers`, exposing configured MCP server tools to Kward turns.
+- Added smartcase, live cursor movement, cancel restore, and visible match highlighting to editor search.
+- Added Vibe editor `:e <filename>` and `:e! <filename>` commands with path tab completion.
+- Added `--skip-config` as an emergency fallback that ignores the main config file for one run.
+
+### Fixed
+
+- Fixed editor undo/redo so selections do not become sticky after restoring buffer contents.
+- Fixed busy composer slash commands so they are blocked instead of being queued or sent as in-flight steering.
+
+## [0.73.1] - 2026-06-30
+
+### Fixed
+
+- Fixed Vibe editor `dG` so it deletes from the current line through the end of the file.
+- Fixed session picker delete confirmation in terminals that send printable keys as CSI-u escape sequences.
+
 ## [0.73.0] - 2026-06-29
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kward (0.73.0)
+    kward (0.74.0)
       base64
       nokogiri
       tiktoken_ruby
@@ -146,7 +146,7 @@ CHECKSUMS
   html-proofer (5.2.1) sha256=fdd958a7cbf9c3255fb96fe7cfc4e611f64e2706e469488a3326309ad007d2fd
   io-event (1.16.2) sha256=9f9cb0a96ea5c3850a672606c65f27bc96d7621399ef6196acbfe2be0cd1279c
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
-  kward (0.73.0)
+  kward (0.74.0)
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   metrics (0.15.0) sha256=61ded5bac95118e995b1bc9ed4a5f19bc9814928a312a85b200abbdac9039072
   minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1

data/doc/configuration.md

@@ -13,6 +13,19 @@ Small examples:
 }
 ```
 
+```json
+{
+  "mcpServers": {
+    "safari": {
+      "command": "/Applications/Safari Technology Preview.app/Contents/MacOS/safaridriver",
+      "args": ["--mcp"]
+    }
+  }
+}
+```
+
+See [MCP servers](mcp.md) for connecting local Model Context Protocol servers such as Safari's browser automation server.
+
 ```json
 {
   "memory": {
@@ -263,7 +276,7 @@ Modern mode uses composer-style keys: `Ctrl+S` saves, `Ctrl+Q` quits, `Ctrl+F` s
 
 Emacs mode uses Emacs-style non-modal keys: `Ctrl+X Ctrl+S` saves, `Ctrl+X Ctrl+C` quits, `Ctrl+S` searches forward, `Ctrl+R` searches backward, `Ctrl+Space` sets the mark, `Ctrl+W` kills the region or previous word, `Alt+W` copies the region, `Ctrl+K` kills to end of line, `Ctrl+Y` yanks, and `Alt+Y` cycles the per-buffer kill ring after a yank.
 
-Vibe mode opens files in normal mode and supports a compact classic-vibe subset: normal/insert/command modes, character and line visual modes with `v`/`V`, `h/j/k/l`, word and line movement, counts, simple `d`/`y` operator motions, `dd`, `yy`, `p`, `/` search, `u` undo, and `:w`, `:q`, `:q!`, `:wq`, `:x`, and `:number` commands. Yanks also copy to the terminal clipboard when OSC 52 is supported.
+Vibe mode opens files in normal mode and supports a compact Vim-style subset: normal/insert/command modes, character, line, and block visual modes, `h/j/k/l`, word and WORD movement, counts, `d`/`y`/`c` operators, line yanks and indentation, case operators, marks, macros, jump-list navigation, linewise paste, search, undo/redo, and common `:w`, `:q`, `:q!`, `:wq`, `:x`, `:e`, substitution, and `:number` commands. Yanks also copy to the terminal clipboard when OSC 52 is supported.
 
 ## Session settings
 

data/doc/mcp.md

@@ -0,0 +1,72 @@
+# MCP servers
+
+Kward can connect to local [Model Context Protocol](https://modelcontextprotocol.io/) servers and expose their tools to the model alongside Kward's built-in workspace tools.
+
+This is useful when another app ships an MCP server for something Kward should be able to inspect or control. For example, Safari Technology Preview includes a Safari MCP server that lets agents inspect pages, console output, network activity, screenshots, and other browser state.
+
+## Configure a local MCP server
+
+Add an `mcpServers` object to your Kward config file:
+
+```json
+{
+  "mcpServers": {
+    "safari": {
+      "command": "/Applications/Safari Technology Preview.app/Contents/MacOS/safaridriver",
+      "args": ["--mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+Kward starts enabled MCP servers with stdio transport, discovers their tools, and advertises those tools to the model. Tool names are prefixed with the server name so they do not collide with built-in tools or tools from another MCP server.
+
+For the Safari MCP server, install Safari Technology Preview and enable:
+
+1. Safari Settings > Advanced > Show features for web developers
+2. Safari Settings > Developer > Enable remote automation and external agents
+
+Then ask Kward something like:
+
+```text
+Open http://localhost:3000 in Safari and check the console for errors.
+```
+
+or:
+
+```text
+Inspect my local app in Safari and tell me why the layout is broken.
+```
+
+## Configuration fields
+
+Each server supports:
+
+- `command` — executable path to launch. Required.
+- `args` — command arguments. Optional.
+- `env` — environment variables to add or override for the server process. Optional.
+- `timeout_seconds` — request timeout for MCP initialization, tool listing, and tool calls. Optional; defaults to 10 seconds.
+- `enabled` — set to `false` to keep a server configured but disabled.
+
+Example with an environment variable and custom timeout:
+
+```json
+{
+  "mcpServers": {
+    "example": {
+      "command": "/usr/local/bin/example-mcp",
+      "args": ["--stdio"],
+      "env": { "EXAMPLE_MODE": "local" },
+      "timeout_seconds": 20
+    }
+  }
+}
+```
+
+## Notes and limitations
+
+- Kward currently supports local stdio MCP servers.
+- Kward currently exposes MCP tools. MCP resources, prompts, sampling, and Streamable HTTP are not implemented yet.
+- MCP tool results are returned to the model as text. Structured content is included as JSON. Image, audio, and resource results are summarized as placeholders for now.
+- MCP servers can expose sensitive local application state. Only configure servers you trust, especially browser automation servers that can read page content or screenshots.

data/doc/rpc.md

@@ -60,6 +60,7 @@ Detailed capability fields include:
 - `auth`: Tauren auth provider format, OpenAI and Anthropic OAuth, OpenRouter API-key login, GitHub/Copilot status reporting, and provider logout for stored credentials. GitHub OAuth login is CLI-only; RPC reports `supported: false` for the GitHub provider with a reason string.
 - `memory`: opt-in structured memory support, interactive prompt injection only, JSON/JSONL local storage, and dedicated `memory/*` methods.
 - `commands`: supported `commands/list` capability for prompt, skill, and plugin command sources, plus plugin execution through `commands/run` or plugin slash turns.
+- `mcp`: local stdio MCP server support through the shared `mcpServers` config. RPC exposes MCP tools to turns; MCP resources, prompts, sampling, and Streamable HTTP are explicitly unsupported for now.
 - `startupResources`: supported startup resource listing for context, skills, prompts, and plugins.
 - `extensionUi`: question bridge support via `ui/question` and `ui/answerQuestion`, plus plugin footer updates via `ui/footer`; other UI primitives are explicitly unsupported.
 - `composer`: composer-only UI features. Interactive session diff totals are explicitly unsupported over RPC (`composer.sessionDiff.supported: false`) because RPC clients already receive per-tool diff results and no live composer status payload is exposed. Clipboard copy is also unsupported over RPC (`composer.copy.supported: false`) because UI clients own clipboard access.

data/doc/usage.md

@@ -104,6 +104,13 @@ kward --working-directory ~/code/project
 kward --working-directory ~/code/project "Summarize this repository"
 ```
 
+If your main config file is broken and prevents startup, use `--skip-config` to ignore it for one run:
+
+```bash
+kward --skip-config doctor
+kward --skip-config edit ~/.kward/config.json
+```
+
 ## Interactive slash commands
 
 Slash commands run local actions in the current session. Most do not send a prompt to the model; exceptions like `/git` and `/workers` orchestrate local flows that may then trigger model work.

data/lib/kward/cli/commands.rb

@@ -77,6 +77,7 @@ module Kward
             #{option.call("--working-directory=PATH")}             Run Kward from PATH
             #{option.call("--mode=MODE")}                          Execution mode: auto, chat, oneshot, filter
             #{option.call("--filter")}                              Shortcut for --mode filter
+            #{option.call("--skip-config")}                         Ignore the main config file for this run
             #{option.call("--help")}, #{option.call("-h")}                         Show this help
             #{option.call("--version")}, #{option.call("-v")}                      Show the installed version
 
@@ -214,6 +215,8 @@ module Kward
             break
           when "--experimental-workers"
             @experimental_workers = true
+          when "--skip-config"
+            @skip_config = true
           when "--filter"
             @requested_mode = "filter"
           when "--mode"

data/lib/kward/cli/doctor.rb

@@ -16,24 +16,27 @@ module Kward
       end
 
       def doctor_checks
-        config = safely_read_config
+        config_result = safely_read_config
+        config = config_result.is_a?(Hash) ? config_result : {}
         [
           doctor_config_check,
-          doctor_config_json_check(config),
+          doctor_config_json_check(config_result),
           doctor_directory_check("Config directory", ConfigFiles.config_dir),
           doctor_directory_check("Session directory", SessionStore.new(cwd: current_workspace_root).session_dir, create: true),
           doctor_workspace_check,
           doctor_model_check,
           doctor_auth_check(config),
-          doctor_pan_check(config),
+          doctor_pan_check(config_result),
           { status: :ok, label: "Color", message: @color_enabled ? "enabled" : "disabled" }
         ]
       end
 
       def safely_read_config
         ConfigFiles.read_config
-      rescue StandardError
-        nil
+      rescue ConfigFiles::ConfigError => e
+        e
+      rescue StandardError => e
+        e
       end
 
       def doctor_config_check
@@ -46,10 +49,13 @@ module Kward
         { status: :warning, label: "Config", message: "not found: #{path}" }
       end
 
-      def doctor_config_json_check(config)
-        return { status: :error, label: "Config JSON", message: "invalid or unreadable" } unless config.is_a?(Hash)
+      def doctor_config_json_check(config_result)
+        return { status: :ok, label: "Config JSON", message: "valid" } if config_result.is_a?(Hash)
+        if config_result.is_a?(ConfigFiles::ConfigError)
+          return { status: :error, label: "Config JSON", message: "invalid: #{config_result.detail}" }
+        end
 
-        { status: :ok, label: "Config JSON", message: "valid" }
+        { status: :error, label: "Config JSON", message: "unreadable: #{config_result.message}" }
       end
 
       def doctor_directory_check(label, path, create: false)
@@ -96,8 +102,10 @@ module Kward
         { status: :warning, label: "Auth", message: "no saved credentials found; run `kward login`" }
       end
 
-      def doctor_pan_check(config)
-        pan = config.to_h["pan_mode"] || {}
+      def doctor_pan_check(config_result)
+        return { status: :warning, label: "Pan mode", message: "skipped because config is invalid" } if config_result.is_a?(ConfigFiles::ConfigError)
+
+        pan = config_result.to_h["pan_mode"] || {}
         if !pan["username"].to_s.empty? && !pan["password"].to_s.empty?
           { status: :ok, label: "Pan mode", message: "credentials configured" }
         else

data/lib/kward/cli/interactive_turn.rb

@@ -184,11 +184,13 @@ module Kward
         poll_result = @prompt.poll_input
         case poll_result
         when String
-          return poll_result if handle_busy_worker_input(poll_result, agent, queued_inputs)
-
-          if slash_command_input?(poll_result)
+          if busy_queued_command?(poll_result)
             queued_inputs << poll_result
             @prompt.set_queued_count(queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
+          elsif slash_command_input?(poll_result)
+            # Slash commands are local control actions. Running or queuing them
+            # from the busy composer is surprising because the state they act on
+            # may have changed by the time the active turn finishes.
           elsif steering && !poll_result.strip.empty?
             begin
               steering.submit(poll_result)
@@ -226,6 +228,10 @@ module Kward
         input.to_s.strip.start_with?("/")
       end
 
+      def busy_queued_command?(input)
+        ["/exit", "/quit", "/new"].include?(input.to_s.strip)
+      end
+
       def handle_busy_worker_input(input, agent, queued_inputs)
         return false unless agent
 

data/lib/kward/cli/tabs.rb

@@ -488,18 +488,15 @@ module Kward
       end
 
       def handle_tab_busy_input(tab, input)
-        command = input.to_s.strip
-        if command == "/workers" || command.start_with?("/workers ") || command == "/tab" || command.start_with?("/tab ")
-          _handled, replacement_agent = handle_local_slash_command(command, tab.agent, @session_store)
-          tab.agent = replacement_agent if replacement_agent?(replacement_agent)
-          restore_busy_input_prompt
-          return
-        end
-
-        if slash_command_input?(input)
+        if busy_queued_command?(input)
           tab.queued_inputs << input
           @prompt.set_queued_count(tab.queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
           return
+        elsif slash_command_input?(input)
+          # Slash commands are local control actions. Running or queuing them
+          # from the busy composer is surprising because the state they act on
+          # may have changed by the time the active turn finishes.
+          return
         end
 
         if tab.steering && !input.to_s.strip.empty?

data/lib/kward/cli.rb

@@ -95,7 +95,7 @@ module Kward
     include CLI::InteractiveTurn
     include CLI::ToolSummaries
 
-    def initialize(argv: ARGV, stdin: STDIN, prompt: TTY::Prompt.new, client: Client.new, session_store: nil, context_usage: ContextUsage.new)
+    def initialize(argv: ARGV, stdin: STDIN, prompt: TTY::Prompt.new, client: nil, session_store: nil, context_usage: ContextUsage.new)
       @argv = argv
       @stdin = stdin
       @prompt = prompt
@@ -109,6 +109,7 @@ module Kward
       @working_directory = nil
       @prompt_delimited = false
       @requested_mode = "auto"
+      @skip_config = false
       @experimental_workers = false
       @foreground_turn_active = false
       @pending_reasoning_config = nil
@@ -122,11 +123,41 @@ module Kward
     # @return [void]
     def run
       @argv = extract_global_options(@argv)
+      ConfigFiles.skip_config = @skip_config
       with_working_directory { dispatch }
+    rescue ConfigFiles::ConfigError => e
+      warn config_error_message(e)
+      exit 1
     rescue ArgumentError => e
       warn e.message
       warn "Run `kward help` for available commands."
       exit 1
+    ensure
+      ConfigFiles.skip_config = false
+    end
+
+    def ensure_client!
+      @client ||= Client.new
+    end
+
+    def config_error_message(error)
+      <<~MESSAGE.rstrip
+        Invalid Kward config #{error.format}.
+
+        File:
+          #{error.path}
+
+        Parser error:
+          #{error.detail}
+
+        Kward cannot safely continue with this config.
+
+        Repair it with:
+          kward edit #{error.path}
+
+        Emergency fallback:
+          kward --skip-config doctor
+      MESSAGE
     end
 
     def dispatch
@@ -173,6 +204,7 @@ module Kward
         end
         raise ArgumentError, command_usage("doctor") unless @argv.length == 1
 
+        ensure_client!
         print_doctor
         return
       end
@@ -194,6 +226,7 @@ module Kward
           return
         end
 
+        ensure_client!
         print_sysprompt(@argv[1..] || [])
         return
       end
@@ -205,6 +238,7 @@ module Kward
         end
         raise ArgumentError, command_usage("rpc") unless @argv.length == 1
 
+        ensure_client!
         Kward::RPC::Server.new(input: @stdin, output: $stdout, client: @client, experimental_workers: @experimental_workers).run
         return
       end
@@ -226,6 +260,7 @@ module Kward
           return
         end
 
+        ensure_client!
         handle_openrouter_command(@argv[1..] || [])
         return
       end
@@ -237,6 +272,7 @@ module Kward
         end
         raise ArgumentError, command_usage("pan") unless @argv.length == 1
 
+        ensure_client!
         PanServer.new(client: @client, working_directory: current_workspace_root).run
         return
       end
@@ -267,6 +303,7 @@ module Kward
     end
 
     def run_prompt_or_interactive
+      ensure_client!
       stdin_input = read_stdin_input
       first_prompt = one_shot_prompt_argument
 

data/lib/kward/config_files.rb

@@ -22,6 +22,17 @@ module Kward
   # config, prompt, skill, plugin, cache, memory, and session locations instead of
   # reconstructing `~/.kward` paths independently.
   module ConfigFiles
+    class ConfigError < StandardError
+      attr_reader :path, :format, :detail
+
+      def initialize(path:, format:, detail:)
+        @path = path
+        @format = format
+        @detail = detail
+        super("Invalid Kward config #{format}: #{path}: #{detail}")
+      end
+    end
+
     MAX_SKILL_FILE_BYTES = 100_000
     MAX_PROMPT_FILE_BYTES = 32 * 1024
     DEFAULT_OVERLAY_SETTINGS = { "alignment" => "center", "width" => "maximum" }.freeze
@@ -45,8 +56,18 @@ module Kward
       end
     end
 
+    @skip_config = false
+
     module_function
 
+    def skip_config=(value)
+      @skip_config = value
+    end
+
+    def skip_config?
+      @skip_config == true
+    end
+
     # Directory that contains Kward's user config and adjacent prompt/skill
     # data. Defaults to `~/.kward`, or the directory of `KWARD_CONFIG_PATH`.
     #
@@ -94,6 +115,7 @@ module Kward
           "auto_resume" => false
         },
         "enforce_workspace_agents_file" => false,
+        "mcpServers" => {},
         "tools" => {
           "workspace_guardrails" => true
         }
@@ -103,6 +125,7 @@ module Kward
     # Performs ensure default config for configuration file and path handling.
     def ensure_default_config!(path = config_path)
       path = File.expand_path(path)
+      return false if skip_config? && path == config_path
       return false if File.exist?(path)
 
       write_config(default_config, path)
@@ -156,11 +179,12 @@ module Kward
     # @return [Hash] parsed config object
     def read_config(path = config_path)
       path = File.expand_path(path)
+      return {} if skip_config? && path == config_path
       return {} unless File.exist?(path)
 
       JSON.parse(File.read(path))
-    rescue JSON::ParserError
-      raise "Invalid Kward config JSON: #{path}"
+    rescue JSON::ParserError => e
+      raise ConfigError.new(path: path, format: "JSON", detail: e.message)
     end
 
     # Writes config JSON using private file permissions.
@@ -168,6 +192,9 @@ module Kward
     # @param config [Hash] config object to persist
     # @param path [String] config file path
     def write_config(config, path = config_path)
+      path = File.expand_path(path)
+      raise "Cannot write Kward config while --skip-config is active: #{path}" if skip_config? && path == config_path
+
       PrivateFile.write_json(path, config)
     end
 
@@ -361,6 +388,12 @@ module Kward
       value.is_a?(Hash) ? value : {}
     end
 
+    # Returns configured MCP stdio servers, or an empty config when absent.
+    def mcp_servers(config = read_config)
+      value = config["mcpServers"] || config.dig("mcp", "servers")
+      value.is_a?(Hash) ? value : {}
+    end
+
     # Validates and persists terminal overlay settings.
     def update_overlay_settings(values)
       raise "Overlay settings must be an object" unless values.is_a?(Hash)

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
+
+      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,55 @@
+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)
+        servers = ConfigFiles.mcp_servers(config)
+
+        servers.filter_map do |name, settings|
+          client_from_settings(name, settings)
+        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