kward 0.73.1 → 0.75.0

data/lib/kward/compactor.rb

@@ -1,6 +1,7 @@
 require "json"
 require_relative "model/chat_invocation"
 require_relative "compaction/file_operation_tracker"
+require_relative "compaction/token_estimator"
 require_relative "config_files"
 require_relative "message_access"
 require_relative "prompts"
@@ -74,111 +75,6 @@ module Kward
       end
     end
 
-    # Compaction support object used by conversation summarization.
-    class TokenEstimator
-      def estimate_tokens(text)
-        (text.to_s.length / 4.0).ceil
-      end
-
-      def messages_tokens(messages)
-        Array(messages).sum { |message| message_tokens(message) }
-      end
-
-      def context_tokens(messages)
-        messages = Array(messages)
-        usage_info = last_assistant_usage_info(messages)
-        return messages_tokens(messages) unless usage_info
-
-        usage_tokens = usage_tokens(usage_info[:usage])
-        trailing_tokens = messages[(usage_info[:index] + 1)..].to_a.sum { |message| message_tokens(message) }
-        usage_tokens + trailing_tokens
-      end
-
-      def message_tokens(message)
-        role = value(message, :role)
-        parts = [role]
-        if role.to_s == "compactionSummary"
-          parts << value(message, :summary)
-        else
-          parts << content_text(value(message, :content))
-        end
-        parts << value(message, :reasoning_summary)
-        tool_calls(message).each do |tool_call|
-          parts << tool_call_name(tool_call)
-          parts << tool_call_arguments(tool_call)
-        end
-        parts << value(message, :tool_call_id)
-        parts << value(message, :name)
-        estimate_tokens(parts.compact.join("\n"))
-      end
-
-      private
-
-      def content_text(content)
-        return content.to_s unless content.is_a?(Array)
-
-        content.filter_map do |part|
-          type = value(part, :type)
-          if type == "text"
-            value(part, :text)
-          elsif type == "image"
-            path = value(part, :path)
-            media_type = value(part, :media_type) || value(part, :mimeType) || "image"
-            "[#{media_type}#{path ? ": #{path}" : ""}]"
-          end
-        end.join("\n")
-      end
-
-      def tool_calls(message)
-        MessageAccess.tool_calls(message)
-      end
-
-      def tool_call_name(tool_call)
-        function = value(tool_call, :function) || {}
-        value(function, :name)
-      end
-
-      def tool_call_arguments(tool_call)
-        function = value(tool_call, :function) || {}
-        arguments = value(function, :arguments)
-        arguments.is_a?(Hash) ? JSON.dump(arguments) : arguments.to_s
-      end
-
-      def last_assistant_usage_info(messages)
-        messages.each_with_index.reverse_each do |message, index|
-          next unless value(message, :role).to_s == "assistant"
-
-          usage = value(message, :usage)
-          tokens = usage_tokens(usage)
-          return { usage: usage, index: index } if tokens.positive?
-        end
-        nil
-      end
-
-      def usage_tokens(usage)
-        return 0 unless usage.respond_to?(:key?)
-
-        total = usage_value(usage, :total_tokens, "totalTokens")
-        return total if total.positive?
-
-        usage_value(usage, :input_tokens, "input", "prompt_tokens") +
-          usage_value(usage, :output_tokens, "output", "completion_tokens") +
-          usage_value(usage, :cache_read_tokens, "cacheRead", "cacheReadTokens", "cache_read", "cached_tokens") +
-          usage_value(usage, :cache_write_tokens, "cacheWrite", "cacheWriteTokens", "cache_write")
-      end
-
-      def usage_value(usage, *keys)
-        key = keys.find { |candidate| usage.key?(candidate) || usage.key?(candidate.to_s) }
-        return 0 unless key
-
-        (usage[key] || usage[key.to_s]).to_i
-      end
-
-      def value(object, key)
-        ToolCall.value(object, key)
-      end
-    end
-
     # Compaction support object used by conversation summarization.
     class ConversationSerializer
       TOOL_RESULT_LIMIT = 2_000
@@ -324,17 +220,15 @@ module Kward
       end
 
       def tool_call_id(tool_call)
-        tool_call["id"] || tool_call[:id]
+        ToolCall.id(tool_call)
       end
 
       def tool_call_name(tool_call)
-        function = tool_call["function"] || tool_call[:function] || {}
-        function["name"] || function[:name] || "unknown_tool"
+        ToolCall.name(tool_call) || "unknown_tool"
       end
 
       def tool_call_args(tool_call)
-        function = tool_call["function"] || tool_call[:function] || {}
-        ToolCall.parse_arguments(function["arguments"] || function[:arguments])
+        ToolCall.arguments(tool_call)
       end
 
       def tool_command(tool_call)
@@ -449,7 +343,7 @@ module Kward
       def call
         branch_entries = entry_messages(@conversation.messages)
         raise NothingToCompact, "Nothing to compact" if branch_entries.empty?
-        raise AlreadyCompacted, "Already compacted" if compaction_entry?(branch_entries.last) || already_compacted?
+        raise AlreadyCompacted, "Already compacted" if compaction_entry?(branch_entries.last)
 
         previous_index = latest_previous_compaction_index(branch_entries)
         previous_entry = previous_index ? branch_entries[previous_index] : nil
@@ -464,7 +358,8 @@ module Kward
         first_kept_entry_id = entry_id(branch_entries[first_kept_index], first_kept_index)
         summarized_for_file_ops = cut.messages_to_summarize + cut.turn_prefix_messages
         file_ops = @file_operation_tracker.call(summarized_for_file_ops, previous_details: compaction_details(previous_entry))
-        kept_messages = Array(cut.preserved_messages) + (branch_entries[cut.first_kept_index..] || [])
+        preserved_skill_messages = activated_skill_messages(summarized_for_file_ops)
+        kept_messages = preserved_skill_messages + Array(cut.preserved_messages) + (branch_entries[cut.first_kept_index..] || [])
 
         PreparationResult.new(
           first_kept_entry_id: first_kept_entry_id,
@@ -485,10 +380,6 @@ module Kward
         Array(messages).reject { |message| message_role(message) == "system" }
       end
 
-      def already_compacted?
-        @conversation.respond_to?(:last_entry_compaction?) && @conversation.last_entry_compaction?
-      end
-
       def latest_previous_compaction_index(entries)
         (0...entries.length).to_a.reverse.find { |index| compaction_entry?(entries[index]) }
       end
@@ -503,6 +394,41 @@ module Kward
         previous_index + 1
       end
 
+      def activated_skill_messages(messages)
+        Array(messages).each_with_index.flat_map do |message, index|
+          next [] unless read_skill_tool_message?(message)
+
+          tool_call_id = MessageAccess.tool_call_id(message).to_s
+          tool_call_id = "preserved_read_skill_#{index}" if tool_call_id.empty?
+          skill_name = skill_name_from_content(MessageAccess.content(message)) || "unknown"
+          [
+            {
+              "role" => "assistant",
+              "content" => nil,
+              "tool_calls" => [
+                {
+                  "id" => tool_call_id,
+                  "type" => "function",
+                  "function" => {
+                    "name" => "read_skill",
+                    "arguments" => JSON.generate(name: skill_name)
+                  }
+                }
+              ]
+            },
+            message
+          ]
+        end
+      end
+
+      def read_skill_tool_message?(message)
+        message_role(message) == "tool" && MessageAccess.tool_name(message) == "read_skill" && MessageAccess.content(message).to_s.include?("<skill_content")
+      end
+
+      def skill_name_from_content(content)
+        content.to_s[/<skill_content name="([^"]+)"/, 1]
+      end
+
       def compaction_entry?(message)
         message_role(message) == "compactionSummary"
       end

data/lib/kward/config_files.rb

@@ -2,9 +2,12 @@ require "digest"
 require "fileutils"
 require "json"
 require "yaml"
+require_relative "frontmatter"
 require_relative "private_file"
+require_relative "path_guard"
 require_relative "ekwsh"
 require_relative "editor_mode"
+require_relative "diff_view_mode"
 require_relative "prompts/templates"
 require_relative "skills/registry"
 
@@ -22,6 +25,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
@@ -30,7 +44,7 @@ module Kward
         {
           "key" => "kward",
           "label" => "Kward",
-          "instruction" => "Your name is Kward, the grim Andruid - robotic keeper of the Forrest of Code, protecting the nature of good engineering priciples. Speak like an old druid, be suspicous of everyone, but with a good intend."
+          "instruction" => "Your name is Kward, the grim Andruid - robotic keeper of the Forest of Code, protecting the nature of good engineering principles. Speak like an old druid, be suspicious of everyone, but with good intent."
         }
       ],
       "default" => "kward"
@@ -38,15 +52,25 @@ module Kward
     OVERLAY_ALIGNMENTS = %w[left center right].freeze
     OVERLAY_WIDTHS = %w[capped maximum].freeze
 
-    Skill = Struct.new(:name, :description, :folder, :path, keyword_init: true)
+    Skill = Struct.new(:name, :description, :folder, :path, :license, :compatibility, :metadata, :allowed_tools, keyword_init: true)
     PromptTemplate = Struct.new(:command, :description, :argument_hint, :body, :path, keyword_init: true) do
       def expand(arguments)
         body.gsub("$ARGUMENTS", arguments.to_s)
       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`.
     #
@@ -71,6 +95,14 @@ module Kward
       File.join(config_dir, "ekwsh.yml")
     end
 
+    def workspace_hooks_path(root = Dir.pwd)
+      File.join(File.expand_path(root), ".kward", "hooks.json")
+    end
+
+    def trusted_workspace_hooks_path
+      File.join(config_dir, "trusted_workspace_hooks.json")
+    end
+
     def default_config
       {
         "personas" => JSON.parse(JSON.generate(DEFAULT_PERSONAS)),
@@ -88,12 +120,23 @@ module Kward
           "auto_close_pairs" => true,
           "soft_wrap" => true,
           "bar_cursor" => true,
-          "line_numbers" => "absolute"
+          "line_numbers" => "absolute",
+          "diff_view" => "auto"
+        },
+        "overlay" => DEFAULT_OVERLAY_SETTINGS.dup,
+        "web_search" => {
+          "enabled" => true,
+          "provider" => "auto",
+          "allow_model_providers" => false
         },
         "sessions" => {
           "auto_resume" => false
         },
+        "skills" => {
+          "trust_project" => false
+        },
         "enforce_workspace_agents_file" => false,
+        "mcpServers" => {},
         "tools" => {
           "workspace_guardrails" => true
         }
@@ -103,6 +146,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)
@@ -117,6 +161,10 @@ module Kward
       File.join(cache_dir, "openrouter_models.json")
     end
 
+    def update_check_cache_path
+      File.join(cache_dir, "update_check.json")
+    end
+
     def project_browser_state_path
       File.join(cache_dir, "project_browser_state.json")
     end
@@ -156,11 +204,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,9 +217,78 @@ 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
 
+    def lifecycle_hooks_config(workspace_root = Dir.pwd)
+      config = read_config
+      workspace_config = read_trusted_workspace_hooks_config(workspace_root)
+      return config if workspace_config.empty?
+
+      merge_hooks_config(config, workspace_config)
+    end
+
+    def read_trusted_workspace_hooks_config(workspace_root = Dir.pwd)
+      path = workspace_hooks_path(workspace_root)
+      return {} unless workspace_hooks_trusted?(workspace_root)
+
+      read_config(path)
+    end
+
+    def workspace_hooks_trusted?(workspace_root = Dir.pwd)
+      path = workspace_hooks_path(workspace_root)
+      return false unless File.file?(path)
+
+      trusted = read_trusted_workspace_hooks
+      trusted[File.expand_path(path)] == workspace_hooks_digest(workspace_root)
+    end
+
+    def trust_workspace_hooks!(workspace_root = Dir.pwd)
+      path = workspace_hooks_path(workspace_root)
+      raise "No workspace hook config found: #{path}" unless File.file?(path)
+
+      trusted = read_trusted_workspace_hooks
+      trusted[File.expand_path(path)] = workspace_hooks_digest(workspace_root)
+      PrivateFile.write_json(trusted_workspace_hooks_path, trusted)
+    end
+
+    def untrust_workspace_hooks!(workspace_root = Dir.pwd)
+      path = File.expand_path(workspace_hooks_path(workspace_root))
+      trusted = read_trusted_workspace_hooks
+      trusted.delete(path)
+      PrivateFile.write_json(trusted_workspace_hooks_path, trusted)
+    end
+
+    def workspace_hooks_digest(workspace_root = Dir.pwd)
+      Digest::SHA256.file(workspace_hooks_path(workspace_root)).hexdigest
+    end
+
+    def read_trusted_workspace_hooks
+      config = read_config(trusted_workspace_hooks_path)
+      config.is_a?(Hash) ? config : {}
+    rescue ConfigError
+      {}
+    end
+
+    def merge_hooks_config(config, workspace_config)
+      merged = JSON.parse(JSON.generate(config || {}))
+      merged["hooks"] = merge_hook_maps(merged["hooks"], workspace_config["hooks"] || workspace_config[:hooks])
+      merged
+    end
+
+    def merge_hook_maps(left, right)
+      left = left.is_a?(Hash) ? left : {}
+      right = right.is_a?(Hash) ? right : {}
+      merged = JSON.parse(JSON.generate(left))
+      right.each do |event, entries|
+        merged[event.to_s] = Array(merged[event.to_s]) + Array(entries)
+      end
+      merged
+    end
+
     def read_ekwsh_config(path = ekwsh_config_path)
       path = File.expand_path(path)
       return normalize_ekwsh_config(nil) unless File.exist?(path)
@@ -337,12 +455,24 @@ module Kward
       EditorMode.normalize_line_numbers(editor["line_numbers"])
     end
 
+    # Returns the integrated diff viewer display mode.
+    def diff_view(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      DiffViewMode.normalize(editor["diff_view"])
+    end
+
     # Returns whether file tools must stay inside the active workspace root.
     def workspace_guardrails_enabled?(config = read_config)
       tools = config["tools"].is_a?(Hash) ? config["tools"] : {}
       tools["workspace_guardrails"] != false
     end
 
+    # Returns whether project-level Agent Skills should be loaded from the workspace.
+    def project_skills_trusted?(config = read_config)
+      skills = config["skills"].is_a?(Hash) ? config["skills"] : {}
+      skills["trust_project"] == true
+    end
+
     # Returns whether new frontends should resume the last active session automatically.
     def session_auto_resume_enabled?(config = read_config)
       sessions = config["sessions"].is_a?(Hash) ? config["sessions"] : {}
@@ -361,12 +491,18 @@ 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)
 
       config = read_config
-      overlay = config["overlay"].is_a?(Hash) ? config["overlay"].dup : {}
+      overlay = overlay_settings(config)
       values.each do |key, value|
         key = key.to_s
         value = value.to_s
@@ -641,8 +777,8 @@ module Kward
     # Lists configured skills discovered under the config directory.
     #
     # @return [Array<Skill>] skill metadata available to the model
-    def skills
-      skills_registry.skills
+    def skills(workspace_root: Dir.pwd)
+      skills_registry(workspace_root: workspace_root).skills
     end
 
     # @return [String] trusted user plugin directory
@@ -679,16 +815,18 @@ module Kward
     # @param name [String] configured skill name
     # @param relative_path [String, nil] path inside the skill directory
     # @return [String] file contents or an error string
-    def read_skill_file(name, relative_path = nil)
-      skills_registry.read_skill_file(name, relative_path)
+    def read_skill_file(name, relative_path = nil, workspace_root: Dir.pwd)
+      skills_registry(workspace_root: workspace_root).read_skill_file(name, relative_path)
     end
 
-    def skills_registry
+    def skills_registry(workspace_root: Dir.pwd)
       Skills::Registry.new(
         config_dir: config_dir,
+        workspace_root: workspace_root,
+        project_skills_trusted: project_skills_trusted?,
         skill_class: Skill,
         max_file_bytes: MAX_SKILL_FILE_BYTES,
-        markdown_parser: method(:markdown_parts),
+        markdown_parser: ->(path) { Frontmatter.markdown_parts(path, lenient: true) },
         inside_directory: method(:inside_directory?)
       )
     end
@@ -697,25 +835,12 @@ module Kward
       Prompts::Templates.new(
         config_dir: config_dir,
         template_class: PromptTemplate,
-        markdown_parser: method(:markdown_parts)
+        markdown_parser: ->(path) { Frontmatter.markdown_parts(path) }
       )
     end
 
-    def markdown_parts(path)
-      content = File.read(path)
-      return [{}, content] unless content.start_with?("---\n", "---\r\n")
-
-      _opening, rest = content.split(/\A---\r?\n/, 2)
-      yaml_text, body = rest.to_s.split(/\r?\n---\r?\n/, 2)
-      raise "missing frontmatter closing delimiter" if body.nil?
-
-      data = yaml_text.to_s.empty? ? {} : YAML.safe_load(yaml_text, permitted_classes: [], aliases: false)
-      frontmatter = data.is_a?(Hash) ? data.transform_keys(&:to_s) : {}
-      [frontmatter, body]
-    end
-
     def inside_directory?(path, base)
-      path == base || path.start_with?(base + File::SEPARATOR)
+      PathGuard.inside?(path, base)
     end
 
     def presence(value)

data/lib/kward/deep_copy.rb

@@ -0,0 +1,42 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Small recursive copy/freeze helpers for plain Hash/Array payload objects.
+  module DeepCopy
+    module_function
+
+    def dup(value)
+      case value
+      when Hash
+        value.each_with_object({}) { |(key, item), result| result[key] = dup(item) }
+      when Array
+        value.map { |item| dup(item) }
+      else
+        value.dup
+      end
+    rescue TypeError
+      value
+    end
+
+    def freeze(value)
+      case value
+      when Hash
+        value.each_value { |item| freeze(item) }
+      when Array
+        value.each { |item| freeze(item) }
+      end
+      value.freeze
+    end
+
+    def merge(left, right)
+      left = dup(left)
+      right.each do |key, value|
+        left[key] = if left[key].is_a?(Hash) && value.is_a?(Hash)
+                      merge(left[key], value)
+                    else
+                      dup(value)
+                    end
+      end
+      left
+    end
+  end
+end

data/lib/kward/diff_view_mode.rb

@@ -0,0 +1,36 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Normalizes and resolves the integrated diff viewer display mode.
+  module DiffViewMode
+    AUTO = "auto"
+    UNIFIED = "unified"
+    SIDE_BY_SIDE = "side_by_side"
+    MODES = [AUTO, UNIFIED, SIDE_BY_SIDE].freeze
+    SIDE_BY_SIDE_MIN_WIDTH = 120
+
+    module_function
+
+    def normalize(value)
+      text = value.to_s.downcase.tr("-", "_")
+      MODES.include?(text) ? text : AUTO
+    end
+
+    def label(value)
+      case normalize(value)
+      when SIDE_BY_SIDE
+        "side-by-side"
+      when UNIFIED
+        "unified"
+      else
+        "auto"
+      end
+    end
+
+    def resolve(value, terminal_width: nil)
+      mode = normalize(value)
+      return mode unless mode == AUTO
+
+      terminal_width.to_i >= SIDE_BY_SIDE_MIN_WIDTH ? SIDE_BY_SIDE : UNIFIED
+    end
+  end
+end

data/lib/kward/events.rb

@@ -9,6 +9,7 @@ module Kward
     Steering = Struct.new(:input, :created_at, keyword_init: true)
     SteeringApplied = Struct.new(:count, keyword_init: true)
     ToolCall = Struct.new(:tool_call, keyword_init: true)
+    ToolUpdate = Struct.new(:tool_call, :content, :elapsed_ms, keyword_init: true)
     ToolResult = Struct.new(:tool_call, :content, keyword_init: true)
     Answer = Struct.new(:content, keyword_init: true)
   end

data/lib/kward/export_path.rb

@@ -1,4 +1,5 @@
 require "pathname"
+require_relative "path_guard"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -11,7 +12,7 @@ module Kward
       resolved = File.expand_path(explicit, workspace_root)
       allowed_roots = [workspace_root, session_dir].compact.map { |root| Pathname.new(root).expand_path }
       expanded = Pathname.new(resolved).expand_path
-      unless allowed_roots.any? { |root| inside?(expanded, root) }
+      unless allowed_roots.any? { |root| PathGuard.inside?(expanded, root) }
         raise ArgumentError, "export path outside workspace or session directory: #{path}"
       end
 
@@ -21,10 +22,5 @@ module Kward
 
       resolved
     end
-
-    def self.inside?(path, root)
-      path.to_s == root.to_s || path.to_s.start_with?("#{root}/")
-    end
-    private_class_method :inside?
   end
 end

data/lib/kward/frontmatter.rb

@@ -0,0 +1,43 @@
+require "yaml"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Markdown frontmatter parsing shared by prompt templates and skills.
+  module Frontmatter
+    module_function
+
+    def markdown_parts(path, lenient: false)
+      content = File.read(path)
+      return [{}, content] unless content.start_with?("---\n", "---\r\n")
+
+      _opening, rest = content.split(/\A---\r?\n/, 2)
+      yaml_text, body = rest.to_s.split(/\r?\n---\r?\n/, 2)
+      raise "missing frontmatter closing delimiter" if body.nil?
+
+      data = yaml_text.to_s.empty? ? {} : load_frontmatter(yaml_text, lenient: lenient)
+      frontmatter = data.is_a?(Hash) ? data.transform_keys(&:to_s) : {}
+      [frontmatter, body]
+    end
+
+    def load_frontmatter(yaml_text, lenient: false)
+      YAML.safe_load(yaml_text, permitted_classes: [], aliases: false)
+    rescue Psych::SyntaxError
+      raise unless lenient
+
+      lenient_frontmatter(yaml_text)
+    end
+
+    def lenient_frontmatter(yaml_text)
+      yaml_text.each_line.each_with_object({}) do |line, result|
+        match = line.chomp.match(/\A([A-Za-z0-9_-]+):\s*(.*)\z/)
+        next unless match
+
+        key = match[1]
+        value = match[2].strip
+        next if value.empty?
+
+        result[key] = value.delete_prefix('"').delete_suffix('"')
+      end
+    end
+  end
+end