swarm_memory 2.1.7 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd1cc28cb4976bd82c75c38ae17d92b15b6e9b91d4ef92ae7269759af0a90084
-  data.tar.gz: dd78b137e33ecb3132f864cefb077ecf4add04196421f6206bad4a428bba42d3
+  metadata.gz: 1ec97e62d89963ca0ba1c40d2d4bed76f3cd7ce12c5971594cf93a877228d894
+  data.tar.gz: a6cd54d0e51d4743968758bb3363aad5cdae6e7e21ff25dd688c8f5c36ecfb24
 SHA512:
-  metadata.gz: 25e9b5ead6b852bf5338b7c342043d08a9b3c38e3eff6f3fd2043c14f5caea264764f3fbd2ce4bb3398db286b886eea2d53d4b3ef7e789c26f8d8c4177b37722
-  data.tar.gz: 20c98443c3e0e7f4b2d662d80d03a0ecb0dbcf29d726a12c75a4d506c87c88f2a97e51420033b8d62e5b82573228dfeb4ca2788a30f813e4fe58b26db68ad437
+  metadata.gz: d96db1ab430ec011d572e2472866a121a470ebe3b6afca676d78f1c87d64ba3bdbd4857731a7c25feb597e350dec82749464ab98fca738b93bf799c35ada8776
+  data.tar.gz: 1a8ae4efa93e6259d24962e59453f10ca003913cd2a555086848c586d948896965888ac5c8d8c2dde44961e2d8e33fb4b2a53b908667e29be9e8cc6f82d1a243

data/lib/swarm_memory/integration/sdk_plugin.rb

@@ -22,6 +22,9 @@ module SwarmMemory
         # Track memory mode for each agent: { agent_name => mode }
         # Modes: :assistant (default), :retrieval, :researcher
         @modes = {}
+        # Track threshold configuration for each agent: { agent_name => config }
+        # Enables per-adapter threshold tuning with ENV fallback
+        @threshold_configs = {}
       end
 
       # Plugin identifier
@@ -49,7 +52,6 @@ module SwarmMemory
           :MemoryGrep,
           :MemoryWrite,
           :MemoryEdit,
-          :MemoryMultiEdit,
           :MemoryDelete,
           :MemoryDefrag,
         ]
@@ -75,7 +77,6 @@ module SwarmMemory
             :MemoryGrep,
             :MemoryWrite,
             :MemoryEdit,
-            :MemoryMultiEdit,
             :MemoryDelete,
             :MemoryDefrag,
           ]
@@ -199,24 +200,36 @@ module SwarmMemory
         end
       end
 
-      # Check if storage should be created for this agent
+      # Check if memory is configured for this agent
+      #
+      # Delegates adapter-specific validation to the adapter itself.
+      # Filesystem adapter requires 'directory', custom adapters may use other keys.
       #
       # @param agent_definition [Agent::Definition] Agent definition
-      # @return [Boolean] True if agent has memory configuration
-      def storage_enabled?(agent_definition)
+      # @return [Boolean] True if agent has valid memory configuration
+      def memory_configured?(agent_definition)
         memory_config = agent_definition.plugin_config(:memory)
         return false if memory_config.nil?
 
-        # MemoryConfig object (from DSL)
+        # MemoryConfig object (from DSL) - delegates to its enabled? method
         return memory_config.enabled? if memory_config.respond_to?(:enabled?)
 
-        # Hash (from YAML) - check for directory key
-        if memory_config.is_a?(Hash)
+        # Hash (from YAML)
+        return false unless memory_config.is_a?(Hash)
+        return false if memory_config.empty?
+
+        adapter = (memory_config[:adapter] || memory_config["adapter"] || :filesystem).to_sym
+
+        case adapter
+        when :filesystem
+          # Filesystem adapter requires directory
           directory = memory_config[:directory] || memory_config["directory"]
-          return !directory.nil? && !directory.to_s.strip.empty?
+          !directory.nil? && !directory.to_s.strip.empty?
+        else
+          # Custom adapters: presence of config is sufficient
+          # Adapter will validate its own requirements during initialization
+          true
         end
-
-        false
       end
 
       # Contribute to agent serialization
@@ -293,9 +306,18 @@ module SwarmMemory
 
         builder.instance_eval do
           memory do
+            # Standard options
             directory(memory_config[:directory]) if memory_config[:directory]
             adapter(memory_config[:adapter]) if memory_config[:adapter]
             mode(memory_config[:mode]) if memory_config[:mode]
+
+            # Pass through all custom adapter options
+            # Handle both symbol and string keys (YAML may have either)
+            standard_keys = [:directory, :adapter, :mode, "directory", "adapter", "mode"]
+            custom_keys = memory_config.keys - standard_keys
+            custom_keys.each do |key|
+              option(key.to_sym, memory_config[key]) # Normalize to symbol
+            end
           end
         end
       end
@@ -336,6 +358,7 @@ module SwarmMemory
         # Store storage and mode using BASE NAME
         @storages[base_name] = storage # ← Changed from agent_name to base_name
         @modes[base_name] = mode # ← Changed from agent_name to base_name
+        @threshold_configs[base_name] = extract_threshold_config(memory_config)
 
         # Get mode-specific tools
         allowed_tools = tools_for_mode(mode)
@@ -384,20 +407,27 @@ module SwarmMemory
         # V7.0: Extract base name for storage lookup (delegation instances share storage)
         base_name = agent_name.to_s.split("@").first.to_sym
         storage = @storages[base_name] # ← Changed from agent_name to base_name
+        config = @threshold_configs[base_name] || {}
 
         return [] unless storage&.semantic_index
         return [] if prompt.nil? || prompt.empty?
 
         # Adaptive threshold based on query length
         # Short queries use lower threshold as they have less semantic richness
-        # Optimal: cutoff=10 words, short=0.25, normal=0.35 (discovered via systematic evaluation)
+        # Fallback chain: config → ENV → default
         word_count = prompt.split.size
-        word_cutoff = (ENV["SWARM_MEMORY_ADAPTIVE_WORD_CUTOFF"] || "10").to_i
+        word_cutoff = config[:adaptive_word_cutoff] ||
+          ENV["SWARM_MEMORY_ADAPTIVE_WORD_CUTOFF"]&.to_i ||
+          10
 
         threshold = if word_count < word_cutoff
-          (ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD_SHORT"] || "0.25").to_f
+          config[:discovery_threshold_short] ||
+            ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD_SHORT"]&.to_f ||
+            0.25
         else
-          (ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD"] || "0.35").to_f
+          config[:discovery_threshold] ||
+            ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD"]&.to_f ||
+            0.35
         end
         reminders = []
 
@@ -482,9 +512,15 @@ module SwarmMemory
           }
         end
 
-        # Get actual weights being used (from ENV or defaults)
-        semantic_weight = (ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"] || "0.5").to_f
-        keyword_weight = (ENV["SWARM_MEMORY_KEYWORD_WEIGHT"] || "0.5").to_f
+        # Get actual weights being used (fallback chain: config → ENV → defaults)
+        base_name = agent_name.to_s.split("@").first.to_sym
+        config = @threshold_configs[base_name] || {}
+        semantic_weight = config[:semantic_weight] ||
+          ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"]&.to_f ||
+          0.5
+        keyword_weight = config[:keyword_weight] ||
+          ENV["SWARM_MEMORY_KEYWORD_WEIGHT"]&.to_f ||
+          0.5
 
         SwarmSDK::LogStream.emit(
           type: "semantic_skill_search",
@@ -545,9 +581,15 @@ module SwarmMemory
           }
         end
 
-        # Get actual weights being used (from ENV or defaults)
-        semantic_weight = (ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"] || "0.5").to_f
-        keyword_weight = (ENV["SWARM_MEMORY_KEYWORD_WEIGHT"] || "0.5").to_f
+        # Get actual weights being used (fallback chain: config → ENV → defaults)
+        base_name = agent_name.to_s.split("@").first.to_sym
+        config = @threshold_configs[base_name] || {}
+        semantic_weight = config[:semantic_weight] ||
+          ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"]&.to_f ||
+          0.5
+        keyword_weight = config[:keyword_weight] ||
+          ENV["SWARM_MEMORY_KEYWORD_WEIGHT"]&.to_f ||
+          0.5
 
         SwarmSDK::LogStream.emit(
           type: "semantic_memory_search",
@@ -626,6 +668,40 @@ module SwarmMemory
 
         reminder
       end
+
+      # Extract threshold configuration from memory config
+      #
+      # Supports both MemoryConfig objects (from DSL) and Hash configs (from YAML).
+      # Extracts semantic search thresholds and hybrid search weights.
+      #
+      # @param memory_config [MemoryConfig, Hash, nil] Memory configuration
+      # @return [Hash] Threshold config with symbol keys
+      def extract_threshold_config(memory_config)
+        return {} unless memory_config
+
+        threshold_keys = [
+          :discovery_threshold,
+          :discovery_threshold_short,
+          :adaptive_word_cutoff,
+          :semantic_weight,
+          :keyword_weight,
+        ]
+
+        if memory_config.respond_to?(:adapter_options)
+          # MemoryConfig object (from DSL)
+          memory_config.adapter_options.slice(*threshold_keys)
+        elsif memory_config.is_a?(Hash)
+          # Hash (from YAML) - handle both symbol and string keys
+          result = {}
+          threshold_keys.each do |key|
+            value = memory_config[key] || memory_config[key.to_s]
+            result[key] = value if value
+          end
+          result
+        else
+          {}
+        end
+      end
     end
   end
 end

data/lib/swarm_memory/optimization/defragmenter.rb

@@ -191,7 +191,7 @@ module SwarmMemory
             "  Semantic similarity: N/A (no embeddings)"
           end
           report << ""
-          report << "  **Suggestion:** Review both entries and consider merging with MemoryMultiEdit"
+          report << "  **Suggestion:** Review both entries and consider merging with MemoryEdit"
           report << ""
         end
 

data/lib/swarm_memory/prompts/memory_researcher.md.erb

@@ -28,7 +28,6 @@ You have persistent memory that learns from conversations and helps you answer q
 - `MemoryGlob` - Browse memory by path pattern
 - `MemoryWrite` - Create new memory
 - `MemoryEdit` - Update existing memory
-- `MemoryMultiEdit` - Update multiple memories at once
 - `MemoryDelete` - Delete a memory
 - `MemoryDefrag` - Optimize memory storage
 - `LoadSkill` - Load a skill and swap tools

data/lib/swarm_memory/tools/load_skill.rb

@@ -148,7 +148,6 @@ module SwarmMemory
           "MemoryWrite",
           "MemoryRead",
           "MemoryEdit",
-          "MemoryMultiEdit",
           "MemoryDelete",
           "MemoryGlob",
           "MemoryGrep",

data/lib/swarm_memory/tools/memory_edit.rb

@@ -162,11 +162,12 @@ module SwarmMemory
         # Get existing entry metadata
         entry = @storage.read_entry(file_path: file_path)
 
-        # Write updated content back (preserving the title)
+        # Write updated content back (preserving the title and metadata)
         @storage.write(
           file_path: file_path,
           content: new_content,
           title: entry.title,
+          metadata: entry.metadata,
         )
 
         # Build success message

data/lib/swarm_memory/tools/memory_read.rb

@@ -35,7 +35,7 @@ module SwarmMemory
         - MemoryRead(file_path: "skill/debugging/api-errors.md") - Read a skill before loading it
 
         **Important:**
-        - Always read entries before editing them with MemoryEdit or MemoryMultiEdit
+        - Always read entries before editing them with MemoryEdit
         - Line numbers in output are for reference only - don't include them when editing
         - Each read is tracked to enforce read-before-edit patterns
       DESC

data/lib/swarm_memory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwarmMemory
-  VERSION = "2.1.7"
+  VERSION = "2.2.1"
 end

data/lib/swarm_memory.rb

@@ -123,8 +123,6 @@ module SwarmMemory
         Tools::MemoryRead.new(storage: storage, agent_name: agent_name)
       when :MemoryEdit
         Tools::MemoryEdit.new(storage: storage, agent_name: agent_name)
-      when :MemoryMultiEdit
-        Tools::MemoryMultiEdit.new(storage: storage, agent_name: agent_name)
       when :MemoryDelete
         Tools::MemoryDelete.new(storage: storage)
       when :MemoryGlob
@@ -158,7 +156,6 @@ module SwarmMemory
         Tools::MemoryWrite.new(storage: storage, agent_name: agent_name),
         Tools::MemoryRead.new(storage: storage, agent_name: agent_name),
         Tools::MemoryEdit.new(storage: storage, agent_name: agent_name),
-        Tools::MemoryMultiEdit.new(storage: storage, agent_name: agent_name),
         Tools::MemoryDelete.new(storage: storage),
         Tools::MemoryGlob.new(storage: storage),
         Tools::MemoryGrep.new(storage: storage),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swarm_memory
 version: !ruby/object:Gem::Version
-  version: 2.1.7
+  version: 2.2.1
 platform: ruby
 authors:
 - Paulo Arruda
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.1
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.1
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -138,7 +138,6 @@ files:
 - lib/swarm_memory/tools/memory_edit.rb
 - lib/swarm_memory/tools/memory_glob.rb
 - lib/swarm_memory/tools/memory_grep.rb
-- lib/swarm_memory/tools/memory_multi_edit.rb
 - lib/swarm_memory/tools/memory_read.rb
 - lib/swarm_memory/tools/memory_write.rb
 - lib/swarm_memory/utils.rb

data/lib/swarm_memory/tools/memory_multi_edit.rb

@@ -1,281 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmMemory
-  module Tools
-    # Tool for performing multiple edits to a memory entry
-    #
-    # Applies multiple edit operations sequentially to a single memory entry.
-    # Each edit sees the result of all previous edits, allowing for
-    # coordinated multi-step transformations.
-    # Each agent has its own isolated memory storage.
-    class MemoryMultiEdit < RubyLLM::Tool
-      description <<~DESC
-        Perform multiple exact string replacements in a single memory entry (applies edits sequentially).
-
-        REQUIRED: Provide BOTH parameters - file_path and edits_json.
-
-        **Required Parameters:**
-        - file_path (REQUIRED): Path to memory entry - MUST start with concept/, fact/, skill/, or experience/
-        - edits_json (REQUIRED): JSON array of edit operations - each must have old_string, new_string, and optionally replace_all
-
-        **MEMORY STRUCTURE (4 Fixed Categories Only):**
-        - concept/{domain}/** - Abstract ideas
-        - fact/{subfolder}/** - Concrete information
-        - skill/{domain}/** - Procedures
-        - experience/** - Lessons
-        INVALID: documentation/, reference/, project/, code/, parallel/
-
-        **JSON Format:**
-        ```json
-        [
-          {"old_string": "text to find", "new_string": "replacement text", "replace_all": false},
-          {"old_string": "another find", "new_string": "another replace", "replace_all": true}
-        ]
-        ```
-
-        **CRITICAL - Before Using This Tool:**
-        1. You MUST use MemoryRead on the entry first - edits without reading will FAIL
-        2. Copy text exactly from MemoryRead output, EXCLUDING the line number prefix
-        3. Line number format: "    123→actual content" - only use text AFTER the arrow
-        4. Edits are applied SEQUENTIALLY - later edits see results of earlier edits
-        5. If ANY edit fails, NO changes are saved (all-or-nothing)
-
-        **How Sequential Edits Work:**
-        ```
-        Original: "status: pending, priority: low"
-
-        Edit 1: "pending" → "in-progress"
-        Result: "status: in-progress, priority: low"
-
-        Edit 2: "low" → "high"  (sees Edit 1's result)
-        Final: "status: in-progress, priority: high"
-        ```
-
-        **Use Cases:**
-        - Making multiple coordinated changes in one operation
-        - Updating several related fields at once
-        - Chaining transformations where order matters
-        - Bulk find-and-replace operations
-
-        **Examples:**
-        ```
-        # Update multiple fields in an experience
-        MemoryMultiEdit(
-          file_path: "experience/api-debugging.md",
-          edits_json: '[
-            {"old_string": "status: in-progress", "new_string": "status: resolved"},
-            {"old_string": "confidence: medium", "new_string": "confidence: high"}
-          ]'
-        )
-
-        # Rename function and update calls in a concept
-        MemoryMultiEdit(
-          file_path: "concept/ruby/functions.md",
-          edits_json: '[
-            {"old_string": "def old_func_name", "new_string": "def new_func_name"},
-            {"old_string": "old_func_name()", "new_string": "new_func_name()", "replace_all": true}
-          ]'
-        )
-        ```
-
-        **Important Notes:**
-        - All edits in the array must be valid JSON objects
-        - Each old_string must be different from its new_string
-        - Each old_string must be unique in content UNLESS replace_all is true
-        - Failed edit shows which previous edits succeeded
-        - More efficient than multiple MemoryEdit calls
-      DESC
-
-      param :file_path,
-        desc: "Path to memory entry - MUST start with concept/, fact/, skill/, or experience/ (e.g., 'experience/api-debugging.md', 'concept/ruby/functions.md')",
-        required: true
-
-      param :edits_json,
-        type: "string",
-        desc: <<~DESC.chomp,
-          JSON array of edit operations. Each edit must have:
-          old_string (exact text to replace),
-          new_string (replacement text),
-          and optionally replace_all (boolean, default false).
-          Example: [{"old_string":"foo","new_string":"bar","replace_all":false}]
-        DESC
-        required: true
-
-      # Initialize with storage instance and agent name
-      #
-      # @param storage [Core::Storage] Storage instance
-      # @param agent_name [String, Symbol] Agent identifier
-      def initialize(storage:, agent_name:)
-        super()
-        @storage = storage
-        @agent_name = agent_name.to_sym
-      end
-
-      # Override name to return simple "MemoryMultiEdit"
-      def name
-        "MemoryMultiEdit"
-      end
-
-      # Execute the tool
-      #
-      # @param file_path [String] Path to memory entry
-      # @param edits_json [String] JSON array of edit operations
-      # @return [String] Success message or error
-      def execute(file_path:, edits_json:)
-        # Validate inputs
-        return validation_error("file_path is required") if file_path.nil? || file_path.to_s.strip.empty?
-
-        # Parse JSON
-        edits = begin
-          JSON.parse(edits_json)
-        rescue JSON::ParserError
-          nil
-        end
-
-        return validation_error("Invalid JSON format. Please provide a valid JSON array of edit operations.") if edits.nil?
-
-        return validation_error("edits must be an array") unless edits.is_a?(Array)
-        return validation_error("edits array cannot be empty") if edits.empty?
-
-        # Read current content (this will raise ArgumentError if entry doesn't exist)
-        content = @storage.read(file_path: file_path)
-
-        # Enforce read-before-edit with content verification
-        unless Core::StorageReadTracker.entry_read?(@agent_name, file_path, @storage)
-          return validation_error(
-            "Cannot edit memory entry without reading it first. " \
-              "You must use MemoryRead on 'memory://#{file_path}' before editing it. " \
-              "This ensures you have the current content to match against.",
-          )
-        end
-
-        # Validate edit operations
-        validated_edits = []
-        edits.each_with_index do |edit, index|
-          unless edit.is_a?(Hash)
-            return validation_error("Edit at index #{index} must be a hash/object with old_string and new_string")
-          end
-
-          # Convert string keys to symbols for consistency
-          edit = edit.transform_keys(&:to_sym)
-
-          unless edit[:old_string]
-            return validation_error("Edit at index #{index} missing required field 'old_string'")
-          end
-
-          unless edit[:new_string]
-            return validation_error("Edit at index #{index} missing required field 'new_string'")
-          end
-
-          # old_string and new_string must be different
-          if edit[:old_string] == edit[:new_string]
-            return validation_error("Edit at index #{index}: old_string and new_string must be different")
-          end
-
-          validated_edits << {
-            old_string: edit[:old_string].to_s,
-            new_string: edit[:new_string].to_s,
-            replace_all: edit[:replace_all] == true,
-            index: index,
-          }
-        end
-
-        # Apply edits sequentially
-        results = []
-        current_content = content
-
-        validated_edits.each do |edit|
-          # Check if old_string exists in current content
-          unless current_content.include?(edit[:old_string])
-            return error_with_results(
-              <<~ERROR.chomp,
-                Edit #{edit[:index]}: old_string not found in memory entry.
-                Make sure it matches exactly, including all whitespace and indentation.
-                Do not include line number prefixes from MemoryRead tool output.
-                Note: This edit follows #{edit[:index]} previous edit(s) which may have changed the content.
-              ERROR
-              results,
-            )
-          end
-
-          # Count occurrences
-          occurrences = current_content.scan(edit[:old_string]).count
-
-          # If not replace_all and multiple occurrences, error
-          if !edit[:replace_all] && occurrences > 1
-            return error_with_results(
-              <<~ERROR.chomp,
-                Edit #{edit[:index]}: Found #{occurrences} occurrences of old_string.
-                Either provide more surrounding context to make the match unique, or set replace_all: true to replace all occurrences.
-              ERROR
-              results,
-            )
-          end
-
-          # Perform replacement
-          new_content = if edit[:replace_all]
-            current_content.gsub(edit[:old_string], edit[:new_string])
-          else
-            current_content.sub(edit[:old_string], edit[:new_string])
-          end
-
-          # Record result
-          replaced_count = edit[:replace_all] ? occurrences : 1
-          results << {
-            index: edit[:index],
-            status: "success",
-            occurrences: replaced_count,
-            message: "Replaced #{replaced_count} occurrence(s)",
-          }
-
-          # Update content for next edit
-          current_content = new_content
-        end
-
-        # Get existing entry
-        entry = @storage.read_entry(file_path: file_path)
-
-        # Write updated content back (preserving the title)
-        @storage.write(
-          file_path: file_path,
-          content: current_content,
-          title: entry.title,
-        )
-
-        # Build success message
-        total_replacements = results.sum { |r| r[:occurrences] }
-        message = "Successfully applied #{validated_edits.size} edit(s) to memory://#{file_path}\n"
-        message += "Total replacements: #{total_replacements}\n\n"
-        message += "Details:\n"
-        results.each do |result|
-          message += "  Edit #{result[:index]}: #{result[:message]}\n"
-        end
-
-        message
-      rescue ArgumentError => e
-        validation_error(e.message)
-      end
-
-      private
-
-      def validation_error(message)
-        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
-      end
-
-      def error_with_results(message, results)
-        output = "<tool_use_error>InputValidationError: #{message}\n\n"
-
-        if results.any?
-          output += "Previous successful edits before error:\n"
-          results.each do |result|
-            output += "  Edit #{result[:index]}: #{result[:message]}\n"
-          end
-          output += "\n"
-        end
-
-        output += "Note: The memory entry has NOT been modified. All or nothing approach - if any edit fails, no changes are saved.</tool_use_error>"
-        output
-      end
-    end
-  end
-end