kward 0.66.0 → 0.67.1

data/lib/kward/cli_transcript_formatter.rb

@@ -0,0 +1,124 @@
+require "base64"
+require_relative "image_attachments"
+require_relative "message_access"
+
+module Kward
+  module CLITranscriptFormatter
+    module_function
+
+    def reasoning(message)
+      direct = MessageAccess.value(message, :reasoning_summary)
+      return direct.to_s unless direct.to_s.empty?
+
+      content = MessageAccess.content(message)
+      return "" unless content.is_a?(Array)
+
+      content.filter_map do |part|
+        type = MessageAccess.value(part, :type)
+        next unless ["thinking", "reasoning"].include?(type)
+
+        MessageAccess.value(part, :thinking) || MessageAccess.value(part, :reasoning) || MessageAccess.value(part, :text)
+      end.join("\n")
+    end
+
+    def content_text(content)
+      case content
+      when Array
+        content.filter_map { |part| content_part_text(part) }.join("\n")
+      else
+        content.to_s
+      end
+    end
+
+    def display_text(message)
+      display_content = MessageAccess.display_content(message)
+      return display_content.to_s unless display_content.nil?
+
+      content_text(MessageAccess.content(message))
+    end
+
+    def user_display_text(message)
+      display_content = MessageAccess.display_content(message)
+      return display_content.to_s unless display_content.nil?
+
+      content = MessageAccess.content(message)
+      return content.to_s unless content.is_a?(Array)
+
+      text = content.filter_map do |part|
+        next unless MessageAccess.value(part, :type) == "text"
+
+        MessageAccess.value(part, :text)
+      end.join("\n")
+      ImageAttachments.display_text_without_references(text, ImageAttachments.references_from_text(text).select { |reference| reference[:status] == :attached })
+    end
+
+    def user_transcript_input(message)
+      content = MessageAccess.content(message)
+      return content.to_s unless content.is_a?(Array)
+
+      user_display_text(message)
+    end
+
+    def image_parts(message)
+      content = MessageAccess.content(message)
+      return [] unless content.is_a?(Array)
+
+      content.select { |part| MessageAccess.value(part, :type) == "image" }
+    end
+
+    def image_references(message)
+      image_parts(message).map { |part| image_part_reference(part) }
+    end
+
+    def synthetic_tool_call(name, id)
+      {
+        "id" => id || "restored_tool",
+        "type" => "function",
+        "function" => { "name" => name || "tool", "arguments" => "{}" }
+      }
+    end
+
+    def full_text(message)
+      content = MessageAccess.content(message)
+      text = if content.is_a?(Array)
+               content.filter_map { |part| MessageAccess.value(part, :text) }.join("\n")
+             else
+               content.to_s
+             end
+      text.strip
+    end
+
+    def content_part_text(part)
+      type = MessageAccess.value(part, :type)
+      if type == "text"
+        MessageAccess.value(part, :text)
+      elsif type == "image"
+        path = MessageAccess.value(part, :path)
+        media_type = MessageAccess.value(part, :media_type) || MessageAccess.value(part, :mimeType) || "image"
+        "[#{media_type}#{path ? ": #{path}" : ""}]"
+      end
+    end
+
+    def image_part_reference(part)
+      data = MessageAccess.value(part, :data)
+      path = MessageAccess.value(part, :path)
+      media_type = MessageAccess.value(part, :media_type) || MessageAccess.value(part, :mimeType) || "image"
+      {
+        status: :attached,
+        type: "image",
+        label: path.to_s.empty? ? "pasted image" : File.basename(path),
+        media_type: media_type,
+        size_bytes: decoded_image_size(data),
+        path: path
+      }
+    end
+
+    def decoded_image_size(data)
+      return nil if data.to_s.empty?
+
+      Base64.decode64(data.to_s.gsub(/\s+/, "")).bytesize
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/kward/compaction/file_operation_tracker.rb

@@ -0,0 +1,46 @@
+require_relative "../message_access"
+require_relative "../tools/tool_call"
+
+module Kward
+  module Compaction
+    class FileOperationTracker
+      def call(messages, previous_details: {})
+        read_files = Array(path_values(previous_details, "read_files", :read_files))
+        modified_files = Array(path_values(previous_details, "modified_files", :modified_files))
+
+        Array(messages).each do |message|
+          next unless MessageAccess.role(message) == "assistant"
+
+          MessageAccess.tool_calls(message).each do |tool_call|
+            name = ToolCall.name(tool_call)
+            args = ToolCall.arguments(tool_call)
+            path = args["path"] || args[:path]
+            case name
+            when "read_file"
+              read_files << path if path
+            when "write_file", "edit_file"
+              modified_files << path if path
+            end
+          end
+        end
+
+        {
+          read_files: sorted_paths(read_files),
+          modified_files: sorted_paths(modified_files)
+        }
+      end
+
+      private
+
+      def sorted_paths(paths)
+        paths.map(&:to_s).reject(&:empty?).uniq.sort
+      end
+
+      def path_values(hash, string_key, symbol_key)
+        return [] unless hash.respond_to?(:key?)
+
+        hash[string_key] || hash[symbol_key] || []
+      end
+    end
+  end
+end

data/lib/kward/compactor.rb

@@ -1,7 +1,9 @@
 require "json"
 require_relative "model/chat_invocation"
+require_relative "compaction/file_operation_tracker"
 require_relative "config_files"
 require_relative "prompts"
+require_relative "tools/tool_call"
 
 module Kward
   module Compaction
@@ -163,9 +165,7 @@ module Kward
       end
 
       def value(object, key)
-        return nil unless object.respond_to?(:key?)
-
-        object[key] || object[key.to_s]
+        ToolCall.value(object, key)
       end
     end
 
@@ -350,71 +350,6 @@ module Kward
       end
     end
 
-    class FileOperationTracker
-      def call(messages, previous_details: {})
-        read_files = Array(path_values(previous_details, "read_files", :read_files))
-        modified_files = Array(path_values(previous_details, "modified_files", :modified_files))
-
-        Array(messages).each do |message|
-          next unless message_role(message) == "assistant"
-
-          message_tool_calls(message).each do |tool_call|
-            name = tool_call_name(tool_call)
-            args = tool_call_args(tool_call)
-            path = args["path"] || args[:path]
-            case name
-            when "read_file"
-              read_files << path if path
-            when "write_file", "edit_file"
-              modified_files << path if path
-            end
-          end
-        end
-
-        {
-          read_files: sorted_paths(read_files),
-          modified_files: sorted_paths(modified_files)
-        }
-      end
-
-      private
-
-      def sorted_paths(paths)
-        paths.map(&:to_s).reject(&:empty?).uniq.sort
-      end
-
-      def path_values(hash, string_key, symbol_key)
-        return [] unless hash.respond_to?(:key?)
-
-        hash[string_key] || hash[symbol_key] || []
-      end
-
-      def message_role(message)
-        message["role"] || message[:role]
-      end
-
-      def message_tool_calls(message)
-        value = message["tool_calls"] || message[:tool_calls]
-        value.is_a?(Array) ? value : []
-      end
-
-      def tool_call_name(tool_call)
-        function = tool_call["function"] || tool_call[:function] || {}
-        function["name"] || function[:name]
-      end
-
-      def tool_call_args(tool_call)
-        function = tool_call["function"] || tool_call[:function] || {}
-        arguments = function["arguments"] || function[:arguments]
-        return arguments if arguments.is_a?(Hash)
-        return {} if arguments.nil? || arguments.empty?
-
-        JSON.parse(arguments)
-      rescue JSON::ParserError
-        {}
-      end
-    end
-
     class CutPointFinder
       VALID_CUT_ROLES = ["user", "assistant", "bash", "custom", "branchSummary"].freeze
 

data/lib/kward/config_files.rb

@@ -63,6 +63,12 @@ module Kward
         },
         "composer" => {
           "busy_help" => true
+        },
+        "sessions" => {
+          "auto_resume" => false
+        },
+        "tools" => {
+          "workspace_guardrails" => true
         }
       }
     end
@@ -165,6 +171,21 @@ module Kward
       composer["busy_help"] != false
     end
 
+    def banner_enabled?(config = read_config)
+      banner = config["banner"].is_a?(Hash) ? config["banner"] : {}
+      banner["enabled"] != false
+    end
+
+    def workspace_guardrails_enabled?(config = read_config)
+      tools = config["tools"].is_a?(Hash) ? config["tools"] : {}
+      tools["workspace_guardrails"] != false
+    end
+
+    def session_auto_resume_enabled?(config = read_config)
+      sessions = config["sessions"].is_a?(Hash) ? config["sessions"] : {}
+      sessions["auto_resume"] == true
+    end
+
     def update_overlay_settings(values)
       raise "Overlay settings must be an object" unless values.is_a?(Hash)
 
@@ -328,28 +349,14 @@ module Kward
     end
 
     def crew_characters(personas)
-      raw = personas["characters"] || personas["crew"]
-      return {} unless raw
-
-      if raw.is_a?(Hash)
-        parse_named_characters(raw)
-      elsif raw.is_a?(Array)
-        parse_named_characters_array(raw)
-      else
-        {}
+      named_character_values(personas) do |_key, definition|
+        extract_character_instruction(definition)
       end
     end
 
     def crew_character_labels(personas)
-      raw = personas["characters"] || personas["crew"]
-      return {} unless raw
-
-      if raw.is_a?(Hash)
-        parse_named_character_labels(raw)
-      elsif raw.is_a?(Array)
-        parse_named_character_labels_array(raw)
-      else
-        {}
+      named_character_values(personas) do |_key, definition|
+        extract_character_label(definition)
       end
     end
 
@@ -372,65 +379,34 @@ module Kward
       presence(labels[key])
     end
 
-    def parse_named_characters(raw)
-      raw.each_with_object({}) do |(key, definition), mapping|
-        instruction = extract_character_instruction(definition)
-        next if instruction.nil?
+    def named_character_values(personas)
+      character_entries(personas["characters"] || personas["crew"]).each_with_object({}) do |(key, definition), mapping|
+        value = yield(key, definition)
+        next if value.to_s.empty?
 
-        mapping[key.to_s] = instruction
+        mapping[key.to_s] = value
       end
     end
 
-    def parse_named_characters_array(raw)
-      raw.each_with_object({}) do |entry, mapping|
-        char_key = nil
-        definition = nil
-
-        if entry.is_a?(Hash) && entry.length == 1 && entry.keys.first.is_a?(String)
-          char_key = entry.keys.first
-          definition = entry.values.first
-        elsif entry.is_a?(Hash)
-          char_key = entry["key"] || entry[:key] || entry["id"] || entry[:id] || entry["name"] || entry[:name]
-          definition = entry
-        end
-
-        next if char_key.to_s.empty?
-
-        instruction = extract_character_instruction(definition)
-        next if instruction.to_s.empty?
-
-        mapping[char_key.to_s] = instruction
-      end
-    end
-
-    def parse_named_character_labels(raw)
-      raw.each_with_object({}) do |(key, definition), mapping|
-        label = extract_character_label(definition)
-        next if label.nil?
-
-        mapping[key.to_s] = label
+    def character_entries(raw)
+      case raw
+      when Hash
+        raw.map { |key, definition| [key, definition] }
+      when Array
+        raw.filter_map { |entry| character_entry(entry) }
+      else
+        []
       end
     end
 
-    def parse_named_character_labels_array(raw)
-      raw.each_with_object({}) do |entry, mapping|
-        char_key = nil
-        definition = nil
-
-        if entry.is_a?(Hash) && entry.length == 1 && entry.keys.first.is_a?(String)
-          char_key = entry.keys.first
-          definition = entry.values.first
-        elsif entry.is_a?(Hash)
-          char_key = entry["key"] || entry[:key] || entry["id"] || entry[:id] || entry["name"] || entry[:name]
-          definition = entry
-        end
-
-        next if char_key.to_s.empty?
-
-        label = extract_character_label(definition)
-        next if label.to_s.empty?
+    def character_entry(entry)
+      return nil unless entry.is_a?(Hash)
 
-        mapping[char_key.to_s] = label
+      if entry.length == 1 && entry.keys.first.is_a?(String)
+        [entry.keys.first, entry.values.first]
+      else
+        key = entry["key"] || entry[:key] || entry["id"] || entry[:id] || entry["name"] || entry[:name]
+        key.to_s.empty? ? nil : [key, entry]
       end
     end
 

data/lib/kward/memory/manager.rb

@@ -167,9 +167,17 @@ module Kward
         record
       end
 
+      def promote_memory(id)
+        id = id.to_s
+        core = core_memories.find { |item| item["id"] == id }
+        return promote_core_to_global(core) if core
+
+        promote_soft_to_core(id)
+      end
+
       def promote_soft_to_core(id)
         soft = soft_memories.find { |item| item["id"] == id.to_s }
-        raise ArgumentError, "Unknown active soft memory: #{id}" unless soft
+        raise ArgumentError, "Unknown active soft memory or workspace core memory: #{id}" unless soft
 
         core = add_core(soft["text"], scope: soft["scope"], tags: soft["tags"], source: "promoted_soft_memory", pinned: true)
         forget_memory(id)
@@ -177,6 +185,20 @@ module Kward
         core
       end
 
+      def relax_core(id, workspace_root: Dir.pwd)
+        id = id.to_s
+        memories = core_memories
+        core = memories.find { |item| item["id"] == id }
+        raise ArgumentError, "Unknown core memory: #{id}" unless core
+        raise ArgumentError, "Only global core memories can be relaxed" unless core["scope"] == "global"
+
+        core["scope"] = workspace_scope(workspace_root)
+        core["updated_at"] = timestamp
+        write_core(memories)
+        append_event("relax", event_ref(core, layer: "core"))
+        core
+      end
+
       def forget_memory(id)
         id = id.to_s
         memories = core_memories
@@ -210,6 +232,16 @@ module Kward
         { "core" => core_memories, "soft" => soft_memories(include_inactive: include_inactive) }
       end
 
+      def hierarchy(workspace_root: Dir.pwd, include_inactive: false)
+        workspace = workspace_scope(workspace_root)
+        core = core_memories
+        {
+          "global_core" => core.select { |item| item["scope"] == "global" },
+          "workspace_core" => core.select { |item| item["scope"] == workspace },
+          "workspace_soft" => soft_memories(include_inactive: include_inactive).select { |item| item["scope"] == workspace }
+        }
+      end
+
       def inspect_memory
         list(include_inactive: true).merge("enabled" => enabled?, "paths" => paths)
       end
@@ -230,14 +262,15 @@ module Kward
         end
 
         scopes = scopes_for(workspace_root)
+        workspace = workspace_scope(workspace_root)
         terms = terms_for(input)
-        core = core_memories.select { |item| scopes.include?(item["scope"]) }.first(max_core)
+        core = ranked_core_memories(workspace).first(max_core)
         core_reasons = core.map { |item| reason_for(item, layer: "core", score: 1.0, reasons: ["scope match", "core memories are preferred"]) }
 
         soft_records_all = soft_memories(include_inactive: true)
         soft_scored = soft_records_all.filter_map do |item|
           next unless item["status"] == "active"
-          next unless scopes.include?(item["scope"])
+          next unless item["scope"] == workspace
           next if expired?(item)
 
           score, reasons = soft_score(item, terms)
@@ -271,14 +304,22 @@ module Kward
         soft = Array(retrieval["soft"])
         return nil if core.empty? && soft.empty?
 
+        global_core = core.select { |item| item["scope"] == "global" }
+        workspace_core = core.reject { |item| item["scope"] == "global" }
+
         lines = ["<kward_memory>"]
-        unless core.empty?
-          lines << "Core Memories:"
-          core.each { |item| lines << "- [#{item["id"]}] #{item["text"]}" }
+        unless global_core.empty?
+          lines << "Global Core Memories:"
+          global_core.each { |item| lines << "- [#{item["id"]}] #{item["text"]}" }
+          lines << ""
+        end
+        unless workspace_core.empty?
+          lines << "Workspace Core Memories:"
+          workspace_core.each { |item| lines << "- [#{item["id"]}] #{item["text"]}" }
           lines << ""
         end
         unless soft.empty?
-          lines << "Relevant Soft Memories:"
+          lines << "Workspace Soft Memories:"
           soft.each { |item| lines << "- [#{item["id"]}] #{item["text"]}" }
           lines << ""
         end
@@ -490,6 +531,24 @@ module Kward
         ["global", workspace_scope(workspace_root)]
       end
 
+      def ranked_core_memories(workspace)
+        memories = core_memories
+        memories.select { |item| item["scope"] == "global" } + memories.select { |item| item["scope"] == workspace }
+      end
+
+      def promote_core_to_global(core)
+        raise ArgumentError, "Only workspace core memories can be promoted" if core["scope"] == "global"
+        raise ArgumentError, "Only workspace core memories can be promoted" unless core["scope"].to_s.start_with?("workspace:")
+
+        memories = core_memories
+        record = memories.find { |item| item["id"] == core["id"] }
+        record["scope"] = "global"
+        record["updated_at"] = timestamp
+        write_core(memories)
+        append_event("promote", event_ref(record, layer: "core"))
+        record
+      end
+
       def workspace_scope(workspace_root)
         "workspace:#{ConfigFiles.canonical_workspace_root(workspace_root)}"
       end