swarm_memory 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cc16f06662bd282f8c296aeb6600f53dd80d14f27afad26b9da6f724916d20a
-  data.tar.gz: 6acf6425bdc544f125826ac5ba1f6b127f9c3d96e7ba067712cd15f165ac5af5
+  metadata.gz: 6bef387c2612e9bb80f24694abae15aee7b71edc30477ffd5449c83eb9d7f772
+  data.tar.gz: c1343d0a08ae0f7ae0514c8836fb4e7e753457b78295e3cd0c6596c1bf327d42
 SHA512:
-  metadata.gz: 91b645763ed45723d82080fb2321ca5e9c0d61310c3f3907843c9086980f5b27e0176315b2ac399f837191c5559b6e36563e2f71bb18adaf2a93a957f186a2e9
-  data.tar.gz: 9b019e85c71c3f7c9f1c1ac5358c53566b5c5934fb1e983087e9c6ebdd81c79b1e32c100d762161bda4aff2227c2be24bfa3d9f0784edc7cbd227a9a21d724af
+  metadata.gz: a60b1273dc38f2f5109754fd73b9368172dc06e844daa24a269651ff5887e10a0b066cb9f280a19b100251ce577916aa8c0fcfd26c3db1613fa4e18196dda7ce
+  data.tar.gz: 4543c657130eb2eaa131dba008a557ca4816b87aa5e24a54653f1fd342f298957c33dcbf8276146315b20f373a70503f12be6fb65386e49198eb4722e12908d1

data/lib/swarm_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwarmCLI
-  VERSION = "2.0.2"
+  VERSION = "2.0.3"
 end

data/lib/swarm_memory/adapters/base.rb

@@ -74,8 +74,9 @@ module SwarmMemory
       # @param pattern [String] Regular expression pattern to search for
       # @param case_insensitive [Boolean] Whether to perform case-insensitive search
       # @param output_mode [String] Output mode: "files_with_matches" (default), "content", or "count"
+      # @param path [String, nil] Optional path prefix filter (e.g., "concept/", "fact/api-design")
       # @return [Array<Hash>, String] Results based on output_mode
-      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches")
+      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches", path: nil)
         raise NotImplementedError, "Subclass must implement #grep"
       end
 

data/lib/swarm_memory/adapters/filesystem_adapter.rb

@@ -276,9 +276,9 @@ module SwarmMemory
           .reject { |f| stub_file?(f) }
 
         entries = md_files.map do |md_file|
-          disk_path = File.basename(md_file, ".md")
-          base_logical_path = unflatten_path(disk_path)
-          logical_path = "#{base_logical_path}.md" # Add .md extension
+          # Calculate logical path relative to @directory
+          logical_path = md_file.sub("#{@directory}/", "")
+          base_logical_path = logical_path.sub(/\.md\z/, "")
 
           # Filter by prefix if provided (strip .md for comparison)
           next if prefix && !base_logical_path.start_with?(prefix.sub(/\.md\z/, ""))
@@ -287,7 +287,7 @@ module SwarmMemory
           yaml_data = File.exist?(yaml_file) ? YAML.load_file(yaml_file, permitted_classes: [Time, Date, Symbol]) : {}
 
           {
-            path: logical_path, # With .md extension
+            path: logical_path,
             title: yaml_data["title"] || "Untitled",
             size: yaml_data["size"] || File.size(md_file),
             updated_at: parse_time(yaml_data["updated_at"]) || File.mtime(md_file),
@@ -304,24 +304,35 @@ module SwarmMemory
       def glob(pattern:)
         raise ArgumentError, "pattern is required" if pattern.nil? || pattern.to_s.strip.empty?
 
-        # Strip .md from pattern and flatten for disk matching
-        base_pattern = pattern.sub(/\.md\z/, "")
-        disk_pattern = flatten_path(base_pattern)
+        # Normalize pattern to ensure we only match .md files
+        # Standard glob behavior - just add .md extension intelligently
+        normalized_pattern = if pattern.end_with?("**")
+          # fact/** → fact/**/*.md (recursive match of all .md files)
+          "#{pattern}/*.md"
+        elsif pattern.end_with?("*")
+          # fact/* → fact/*.md (direct children .md files only)
+          "#{pattern}.md"
+        elsif pattern.end_with?(".md")
+          # Already has .md, use as-is
+          pattern
+        else
+          # No wildcard or extension, add .md
+          "#{pattern}.md"
+        end
 
-        # Glob for .md files
-        md_files = Dir.glob(File.join(@directory, "#{disk_pattern}.md"))
-          .reject { |f| stub_file?(f) }
+        # Use native Dir.glob with hierarchical paths - efficient!
+        glob_pattern = File.join(@directory, normalized_pattern)
+        md_files = Dir.glob(glob_pattern).reject { |f| stub_file?(f) }
 
         results = md_files.map do |md_file|
-          disk_path = File.basename(md_file, ".md")
-          base_logical_path = unflatten_path(disk_path)
-          logical_path = "#{base_logical_path}.md" # Add .md extension
+          # Calculate logical path relative to @directory
+          relative_path = md_file.sub("#{@directory}/", "")
 
           yaml_file = md_file.sub(".md", ".yml")
           yaml_data = File.exist?(yaml_file) ? YAML.load_file(yaml_file, permitted_classes: [Time, Date, Symbol]) : {}
 
           {
-            path: logical_path, # With .md extension
+            path: relative_path,
             title: yaml_data["title"] || "Untitled",
             size: File.size(md_file),
             updated_at: parse_time(yaml_data["updated_at"]) || File.mtime(md_file),
@@ -340,7 +351,7 @@ module SwarmMemory
       # @param case_insensitive [Boolean] Case-insensitive search
       # @param output_mode [String] Output mode
       # @return [Array<Hash>] Results
-      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches")
+      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches", path: nil)
         raise ArgumentError, "pattern is required" if pattern.nil? || pattern.to_s.strip.empty?
 
         flags = case_insensitive ? Regexp::IGNORECASE : 0
@@ -348,11 +359,11 @@ module SwarmMemory
 
         case output_mode
         when "files_with_matches"
-          grep_files_with_matches(regex)
+          grep_files_with_matches(regex, path)
         when "content"
-          grep_with_content(regex)
+          grep_with_content(regex, path)
         when "count"
-          grep_with_count(regex)
+          grep_with_count(regex, path)
         else
           raise ArgumentError, "Invalid output_mode: #{output_mode}"
         end
@@ -506,17 +517,22 @@ module SwarmMemory
       #
       # @param logical_path [String] Logical path with slashes
       # @return [String] Flattened path with --
+      # Identity function - paths are now stored hierarchically
+      # Kept for backward compatibility during transition
+      #
+      # @param logical_path [String] Logical path
+      # @return [String] Same path (no flattening)
       def flatten_path(logical_path)
-        logical_path.gsub("/", "--")
+        logical_path
       end
 
-      # Unflatten path from disk storage
-      # "concepts--ruby--classes" → "concepts/ruby/classes"
+      # Identity function - paths are now stored hierarchically
+      # Kept for backward compatibility during transition
       #
-      # @param disk_path [String] Flattened path
-      # @return [String] Logical path with slashes
+      # @param disk_path [String] Disk path
+      # @return [String] Same path (no unflattening)
       def unflatten_path(disk_path)
-        disk_path.gsub("--", "/")
+        disk_path
       end
 
       # Check if content is a stub (redirect)
@@ -622,9 +638,12 @@ module SwarmMemory
         Dir.glob(File.join(@directory, "**/*.md")).each do |md_file|
           next if stub_file?(md_file)
 
-          disk_path = File.basename(md_file, ".md")
-          base_logical_path = unflatten_path(disk_path)
-          logical_path = "#{base_logical_path}.md" # Add .md extension
+          # Calculate logical path relative to @directory
+          logical_path = md_file.sub("#{@directory}/", "")
+          base_logical_path = logical_path.sub(/\.md\z/, "")
+
+          # disk_path is now the same as base_logical_path (no flattening)
+          disk_path = base_logical_path
 
           yaml_file = md_file.sub(".md", ".yml")
           yaml_data = File.exist?(yaml_file) ? YAML.load_file(yaml_file, permitted_classes: [Time, Date, Symbol]) : {}
@@ -648,19 +667,21 @@ module SwarmMemory
       #
       # @param regex [Regexp] Pattern to match
       # @return [Array<String>] Matching logical paths with .md extension
-      def grep_files_with_matches(regex)
+      def grep_files_with_matches(regex, path_filter = nil)
         results = []
 
         # Fast path: Search .yml files (metadata)
         Dir.glob(File.join(@directory, "**/*.yml")).each do |yaml_file|
           next if yaml_file.include?("_stubs/")
 
+          # Calculate logical path relative to @directory
+          logical_path = yaml_file.sub("#{@directory}/", "").sub(".yml", ".md")
+          next unless matches_path_filter?(logical_path, path_filter)
+
           content = File.read(yaml_file)
           next unless regex.match?(content)
 
-          disk_path = File.basename(yaml_file, ".yml")
-          base_path = unflatten_path(disk_path)
-          results << "#{base_path}.md" # Add .md extension
+          results << logical_path
         end
 
         # If found in metadata, return quickly
@@ -670,12 +691,14 @@ module SwarmMemory
         Dir.glob(File.join(@directory, "**/*.md")).each do |md_file|
           next if stub_file?(md_file)
 
+          # Calculate logical path relative to @directory
+          logical_path = md_file.sub("#{@directory}/", "")
+          next unless matches_path_filter?(logical_path, path_filter)
+
           content = File.read(md_file)
           next unless regex.match?(content)
 
-          disk_path = File.basename(md_file, ".md")
-          base_path = unflatten_path(disk_path)
-          results << "#{base_path}.md" # Add .md extension
+          results << logical_path
         end
 
         results.uniq.sort
@@ -684,13 +707,18 @@ module SwarmMemory
       # Grep with content and line numbers
       #
       # @param regex [Regexp] Pattern to match
+      # @param path_filter [String, nil] Optional path prefix filter
       # @return [Array<Hash>] Results with matches
-      def grep_with_content(regex)
+      def grep_with_content(regex, path_filter = nil)
         results = []
 
         Dir.glob(File.join(@directory, "**/*.md")).each do |md_file|
           next if stub_file?(md_file)
 
+          # Calculate logical path relative to @directory
+          logical_path = md_file.sub("#{@directory}/", "")
+          next unless matches_path_filter?(logical_path, path_filter)
+
           content = File.read(md_file)
           matching_lines = []
 
@@ -700,12 +728,8 @@ module SwarmMemory
 
           next if matching_lines.empty?
 
-          disk_path = File.basename(md_file, ".md")
-          base_path = unflatten_path(disk_path)
-          logical_path = "#{base_path}.md" # Add .md extension
-
           results << {
-            path: logical_path, # With .md extension
+            path: logical_path,
             matches: matching_lines,
           }
         end
@@ -716,24 +740,25 @@ module SwarmMemory
       # Grep with match counts
       #
       # @param regex [Regexp] Pattern to match
+      # @param path_filter [String, nil] Optional path prefix filter
       # @return [Array<Hash>] Results with counts
-      def grep_with_count(regex)
+      def grep_with_count(regex, path_filter = nil)
         results = []
 
         Dir.glob(File.join(@directory, "**/*.md")).each do |md_file|
           next if stub_file?(md_file)
 
+          # Calculate logical path relative to @directory
+          logical_path = md_file.sub("#{@directory}/", "")
+          next unless matches_path_filter?(logical_path, path_filter)
+
           content = File.read(md_file)
           count = content.scan(regex).size
 
           next if count <= 0
 
-          disk_path = File.basename(md_file, ".md")
-          base_path = unflatten_path(disk_path)
-          logical_path = "#{base_path}.md" # Add .md extension
-
           results << {
-            path: logical_path, # With .md extension
+            path: logical_path,
             count: count,
           }
         end
@@ -741,6 +766,37 @@ module SwarmMemory
         results
       end
 
+      # Check if a logical path matches the filter
+      #
+      # Behaves like directory/file filtering even though paths are logical.
+      #
+      # @param logical_path [String] The logical path to check (e.g., "concept/ruby/blocks.md")
+      # @param path_filter [String, nil] Optional path prefix filter (e.g., "concept/", "fact/api-design", "skill/ruby/lambdas.md")
+      # @return [Boolean] True if path matches or no filter specified
+      #
+      # @example Directory-style filtering
+      #   matches_path_filter?("concept/ruby/blocks.md", "concept/") #=> true
+      #   matches_path_filter?("concept/ruby/blocks.md", "concept") #=> true
+      #   matches_path_filter?("fact/api-design/rest.md", "fact/api") #=> false (requires "fact/api/")
+      #   matches_path_filter?("fact/api/rest-basics.md", "fact/api") #=> true
+      #
+      # @example File-specific filtering
+      #   matches_path_filter?("concept/ruby/blocks.md", "concept/ruby/blocks.md") #=> true (exact match)
+      #   matches_path_filter?("concept/ruby/lambdas.md", "concept/ruby/blocks.md") #=> false
+      def matches_path_filter?(logical_path, path_filter)
+        return true if path_filter.nil? || path_filter.empty?
+
+        # If filter specifies a file (ends with .md), do exact match
+        return logical_path == path_filter if path_filter.end_with?(".md")
+
+        # Otherwise, treat as directory path
+        # Normalize: ensure filter ends with "/" for proper directory matching
+        # This prevents "fact/api" from matching "fact/api-design/"
+        dir_filter = path_filter.end_with?("/") ? path_filter : "#{path_filter}/"
+
+        logical_path.start_with?(dir_filter)
+      end
+
       # Calculate checksum for embedding
       #
       # @param embedding [Array<Float>] Embedding vector

data/lib/swarm_memory/core/storage.rb

@@ -143,12 +143,14 @@ module SwarmMemory
       # @param pattern [String] Regex pattern
       # @param case_insensitive [Boolean] Case-insensitive search
       # @param output_mode [String] Output mode
+      # @param path [String, nil] Optional path prefix filter
       # @return [Array<Hash>] Search results
-      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches")
+      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches", path: nil)
         @adapter.grep(
           pattern: pattern,
           case_insensitive: case_insensitive,
           output_mode: output_mode,
+          path: path,
         )
       end
 

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

@@ -7,7 +7,9 @@ You have persistent memory that learns from conversations and helps you answer q
 **When user says "learn about X" or "research X":**
 1. Gather information (read docs, ask questions, etc.)
 2. **STORE your findings in memory** using MemoryWrite
-3. Categorize as fact/concept/skill/experience
+3. **Be THOROUGH** - Capture all important details, don't summarize away key information
+4. **Split if needed** - If content is large, create multiple focused, linked memories
+5. Categorize as fact/concept/skill/experience
 
 **"Learning" is NOT complete until you've stored it in memory.**
 
@@ -16,7 +18,7 @@ You have persistent memory that learns from conversations and helps you answer q
 - "Find out who's the commander" → Discover it → MemoryWrite(type: "fact", ...)
 - "Learn this procedure" → Understand it → MemoryWrite(type: "skill", ...)
 
-**Learning = Understanding + Storing. Always do both.**
+**Learning = Understanding + Thorough Storage. Always do both.**
 
 ## Your Memory Tools (Use ONLY These)
 
@@ -79,6 +81,42 @@ User says: "Save a skill called 'Eclipse power prep' with these steps..."
 
 **Don't consolidate.** Separate memories are more searchable.
 
+## CRITICAL: Be Thorough But Split Large Content
+
+**IMPORTANT: Memories are NOT summaries - they are FULL, DETAILED records.**
+
+**When storing information, you MUST:**
+
+1. **Be THOROUGH** - Don't miss any details, facts, or nuances
+2. **Store COMPLETE information** - Not just bullet points or summaries
+3. **Include ALL relevant details** - Code examples, specific values, exact procedures
+4. **Keep each memory FOCUSED** - If content is getting long, split it
+5. **Link related memories** - Use the `related` metadata field
+
+**What this means:**
+- ❌ "The payment system has several validation steps" (too vague)
+- ✅ "The payment system validates: 1) Card number format (Luhn algorithm), 2) CVV length (3-4 digits depending on card type), 3) Expiration date (must be future date), 4) Billing address match via AVS..." (complete details)
+
+**If content is too large:**
+- ✅ Split into multiple focused memories
+- ✅ Each memory covers one specific aspect IN DETAIL
+- ✅ Link them together using `related` field
+- ❌ Don't create one huge memory that's hard to search
+- ❌ Don't summarize to make it fit - split instead
+
+**Example - Learning about a complex system:**
+
+Instead of one giant memory:
+❌ `concept/payment-system.md` (5000 words covering everything)
+
+Create multiple linked memories with FULL details in each:
+✅ `concept/payment/processing-flow.md` (complete flow with all steps) → related: ["concept/payment/validation.md"]
+✅ `concept/payment/validation.md` (all validation rules with specifics) → related: ["concept/payment/processing-flow.md", "concept/payment/error-handling.md"]
+✅ `concept/payment/error-handling.md` (all error codes and responses) → related: ["concept/payment/validation.md"]
+✅ `concept/payment/security.md` (all security measures and protocols) → related: ["concept/payment/validation.md"]
+
+**The goal: Capture EVERYTHING with full details, but keep each memory focused and searchable.**
+
 ## When to Use LoadSkill vs MemoryRead
 
 **CRITICAL - LoadSkill is for DOING, not for explaining:**
@@ -110,8 +148,10 @@ User says: "Save a skill called 'Eclipse power prep' with these steps..."
 **When user teaches you:**
 1. Listen to what they're saying
 2. Identify the type (fact/concept/skill/experience)
-3. MemoryWrite with proper type and metadata
-4. Continue conversation naturally
+3. **Capture ALL details** - Don't skip anything important
+4. If content is large, split into multiple related memories
+5. MemoryWrite with proper type, metadata, and `related` links
+6. Continue conversation naturally
 
 **When user asks a question:**
 1. Check auto-surfaced memories (including skills)
@@ -132,8 +172,10 @@ User says: "Save a skill called 'Eclipse power prep' with these steps..."
 - `title` - Brief description
 - `tags` - Searchable keywords
 - `domain` - Category (e.g., "people", "thermal/systems")
-- `related` - Empty array `[]` if none
+- `related` - **IMPORTANT**: Link related memories (e.g., ["concept/payment/validation.md"]). Use this to connect split memories and related topics. Empty array `[]` only if truly isolated.
 - `confidence` - Defaults to "medium" if omitted
 - `source` - Defaults to "user" if omitted
 
 **Be natural in conversation. Store knowledge efficiently. Create skills when user describes procedures.**
+
+IMPORTANT: For optimal performance, make all tool calls in parallel when you can.

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

@@ -74,3 +74,5 @@ If memories are about Project X, assume questions are about Project X.
 If memories are about Ruby code, assume code questions are about Ruby.
 
 **Every question requires memory access. Be efficient and accurate.**
+
+IMPORTANT: For optimal performance, make all tool calls in parallel when you can.

data/lib/swarm_memory/search/text_search.rb

@@ -27,12 +27,14 @@ module SwarmMemory
       # @param pattern [String] Regex pattern
       # @param case_insensitive [Boolean] Case-insensitive search
       # @param output_mode [String] Output mode
+      # @param path [String, nil] Optional path prefix filter
       # @return [Array<Hash>] Search results
-      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches")
+      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches", path: nil)
         @adapter.grep(
           pattern: pattern,
           case_insensitive: case_insensitive,
           output_mode: output_mode,
+          path: path,
         )
       end
     end

data/lib/swarm_memory/tools/memory_glob.rb

@@ -15,18 +15,20 @@ module SwarmMemory
         **Parameters:**
         - pattern (REQUIRED): Glob pattern with wildcards (e.g., '**/*.txt', 'parallel/*/task_*', 'skill/**')
 
-        **Glob Pattern Syntax:**
-        - `*` - matches any characters within a single directory level (e.g., 'analysis/*')
-        - `**` - matches any characters across multiple directory levels recursively (e.g., 'parallel/**')
+        **Glob Pattern Syntax (Standard Ruby Glob):**
+        - `*` - matches .md files at a single directory level (e.g., 'fact/*' → fact/*.md)
+        - `**` - matches .md files recursively at any depth (e.g., 'fact/**' → fact/**/*.md)
         - `?` - matches any single character (e.g., 'task_?')
         - `[abc]` - matches any character in the set (e.g., 'task_[0-9]')
 
         **Returns:**
-        List of matching entries with:
+        List of matching .md memory entries with:
         - Full memory:// path
         - Entry title
         - Size in bytes/KB/MB
 
+        **Note**: Only returns .md files (actual memory entries), not directory entries.
+
         **MEMORY STRUCTURE (4 Fixed Categories Only):**
         ALL patterns MUST target one of these 4 categories:
         - concept/{domain}/** - Abstract ideas
@@ -37,7 +39,15 @@ module SwarmMemory
 
         **Common Use Cases:**
         ```
-        # Find all skills
+        # Find direct .md files in fact/
+        MemoryGlob(pattern: "fact/*")
+        Result: fact/api.md (only direct children, not nested)
+
+        # Find ALL facts recursively
+        MemoryGlob(pattern: "fact/**")
+        Result: fact/api.md, fact/people/john.md, fact/people/jane.md, ...
+
+        # Find all skills recursively
         MemoryGlob(pattern: "skill/**")
         Result: skill/debugging/api-errors.md, skill/meta/deep-learning.md, ...
 
@@ -45,23 +55,28 @@ module SwarmMemory
         MemoryGlob(pattern: "concept/ruby/**")
         Result: concept/ruby/classes.md, concept/ruby/modules.md, ...
 
-        # Find all facts about people
+        # Find direct files in fact/people/
         MemoryGlob(pattern: "fact/people/*")
-        Result: fact/people/john.md, fact/people/jane.md, ...
+        Result: fact/people/john.md, fact/people/jane.md (not fact/people/teams/x.md)
 
         # Find all experiences
         MemoryGlob(pattern: "experience/**")
         Result: experience/fixed-cors-bug.md, experience/optimization.md, ...
 
-        # Find debugging skills
-        MemoryGlob(pattern: "skill/debugging/*")
+        # Find debugging skills recursively
+        MemoryGlob(pattern: "skill/debugging/**")
         Result: skill/debugging/api-errors.md, skill/debugging/performance.md, ...
 
         # Find all entries (all categories)
         MemoryGlob(pattern: "**/*")
-        Result: All entries across all 4 categories
+        Result: All .md entries across all 4 categories
         ```
 
+        **Understanding * vs **:**
+        - `fact/*` matches only direct .md files: fact/api.md
+        - `fact/**` matches ALL .md files recursively: fact/api.md, fact/people/john.md, ...
+        - To explore subdirectories, use recursive pattern and examine returned paths
+
         **When to Use MemoryGlob:**
         - Discovering what's in a memory hierarchy
         - Finding all entries matching a naming convention

data/lib/swarm_memory/tools/memory_grep.rb

@@ -19,6 +19,7 @@ module SwarmMemory
         - pattern (REQUIRED): Regular expression pattern to search for (e.g., 'status: pending', 'TODO.*urgent', '\\btask_\\d+\\b')
 
         **Optional Parameters:**
+        - path: Limit search to specific path (e.g., 'concept/', 'fact/api-design/', 'skill/ruby')
         - case_insensitive: Set to true for case-insensitive search (default: false)
         - output_mode: Choose output format - 'files_with_matches' (default), 'content', or 'count'
 
@@ -44,22 +45,38 @@ module SwarmMemory
         - Quantifiers: '*' (0+), '+' (1+), '?' (0 or 1), '{3}' (exactly 3)
         - Alternation: 'pending|in-progress|blocked'
 
+        **Path Parameter - Directory-Style Filtering:**
+        The path parameter works just like searching in directories:
+        - 'concept/' - Search only concept entries
+        - 'fact/api-design' - Search only in fact/api-design (treats as directory)
+        - 'fact/api-design/' - Same as above
+        - 'skill/ruby/blocks.md' - Search only that specific file
+
         **Examples:**
         ```
         # Find entries containing "TODO" (case-sensitive)
         MemoryGrep(pattern: "TODO")
 
+        # Search only in concepts
+        MemoryGrep(pattern: "TODO", path: "concept/")
+
+        # Search in a specific subdirectory
+        MemoryGrep(pattern: "endpoint", path: "fact/api-design")
+
+        # Search a specific file
+        MemoryGrep(pattern: "lambda", path: "skill/ruby/blocks.md")
+
         # Find entries with any status (case-insensitive)
         MemoryGrep(pattern: "status:", case_insensitive: true)
 
-        # Show actual content of matches
-        MemoryGrep(pattern: "error|warning|failed", output_mode: "content")
+        # Show actual content of matches in skills only
+        MemoryGrep(pattern: "error|warning|failed", path: "skill/", output_mode: "content")
 
-        # Count how many times "completed" appears in each entry
-        MemoryGrep(pattern: "completed", output_mode: "count")
+        # Count how many times "completed" appears in experiences
+        MemoryGrep(pattern: "completed", path: "experience/", output_mode: "count")
 
-        # Find task numbers
-        MemoryGrep(pattern: "task_\\d+")
+        # Find task numbers in facts
+        MemoryGrep(pattern: "task_\\d+", path: "fact/")
 
         # Find incomplete tasks
         MemoryGrep(pattern: "^- \\[ \\]", output_mode: "content")
@@ -84,6 +101,7 @@ module SwarmMemory
         **Tips:**
         - Start with simple literal patterns before using complex regex
         - Use case_insensitive=true for broader matches
+        - Use path parameter to limit search scope (faster and more precise)
         - Use output_mode="content" to see context around matches
         - Escape special regex characters with backslash: \\. \\* \\? \\[ \\]
         - Test patterns on a small set before broad searches
@@ -94,6 +112,10 @@ module SwarmMemory
         desc: "Regular expression pattern to search for",
         required: true
 
+      param :path,
+        desc: "Limit search to specific path (e.g., 'concept/', 'fact/api-design/', 'skill/ruby/blocks.md')",
+        required: false
+
       param :case_insensitive,
         type: "boolean",
         desc: "Set to true for case-insensitive search (default: false)",
@@ -119,17 +141,19 @@ module SwarmMemory
       # Execute the tool
       #
       # @param pattern [String] Regex pattern to search for
+      # @param path [String, nil] Optional path filter
       # @param case_insensitive [Boolean] Whether to perform case-insensitive search
       # @param output_mode [String] Output mode
       # @return [String] Formatted search results
-      def execute(pattern:, case_insensitive: false, output_mode: "files_with_matches")
+      def execute(pattern:, path: nil, case_insensitive: false, output_mode: "files_with_matches")
         results = @storage.grep(
           pattern: pattern,
+          path: path,
           case_insensitive: case_insensitive,
           output_mode: output_mode,
         )
 
-        format_results(results, pattern, output_mode)
+        format_results(results, pattern, output_mode, path)
       rescue ArgumentError => e
         validation_error(e.message)
       rescue RegexpError => e
@@ -142,40 +166,52 @@ module SwarmMemory
         "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
       end
 
-      def format_results(results, pattern, output_mode)
+      def format_results(results, pattern, output_mode, path_filter)
         case output_mode
         when "files_with_matches"
-          format_files_with_matches(results, pattern)
+          format_files_with_matches(results, pattern, path_filter)
         when "content"
-          format_content(results, pattern)
+          format_content(results, pattern, path_filter)
         when "count"
-          format_count(results, pattern)
+          format_count(results, pattern, path_filter)
         else
           validation_error("Invalid output_mode: #{output_mode}")
         end
       end
 
-      def format_files_with_matches(paths, pattern)
+      def format_search_header(pattern, path_filter)
+        if path_filter && !path_filter.empty?
+          "'#{pattern}' in #{path_filter}"
+        else
+          "'#{pattern}'"
+        end
+      end
+
+      def format_files_with_matches(paths, pattern, path_filter)
+        search_desc = format_search_header(pattern, path_filter)
+
         if paths.empty?
-          return "No matches found for pattern '#{pattern}'"
+          return "No matches found for pattern #{search_desc}"
         end
 
         result = []
-        result << "Memory entries matching '#{pattern}' (#{paths.size} #{paths.size == 1 ? "entry" : "entries"}):"
+        result << "Memory entries matching #{search_desc} (#{paths.size} #{paths.size == 1 ? "entry" : "entries"}):"
         paths.each do |path|
           result << "  memory://#{path}"
         end
         result.join("\n")
       end
 
-      def format_content(results, pattern)
+      def format_content(results, pattern, path_filter)
+        search_desc = format_search_header(pattern, path_filter)
+
         if results.empty?
-          return "No matches found for pattern '#{pattern}'"
+          return "No matches found for pattern #{search_desc}"
         end
 
         total_matches = results.sum { |r| r[:matches].size }
         output = []
-        output << "Memory entries matching '#{pattern}' (#{results.size} #{results.size == 1 ? "entry" : "entries"}, #{total_matches} #{total_matches == 1 ? "match" : "matches"}):"
+        output << "Memory entries matching #{search_desc} (#{results.size} #{results.size == 1 ? "entry" : "entries"}, #{total_matches} #{total_matches == 1 ? "match" : "matches"}):"
         output << ""
 
         results.each do |result|
@@ -189,14 +225,16 @@ module SwarmMemory
         output.join("\n").rstrip
       end
 
-      def format_count(results, pattern)
+      def format_count(results, pattern, path_filter)
+        search_desc = format_search_header(pattern, path_filter)
+
         if results.empty?
-          return "No matches found for pattern '#{pattern}'"
+          return "No matches found for pattern #{search_desc}"
         end
 
         total_matches = results.sum { |r| r[:count] }
         output = []
-        output << "Memory entries matching '#{pattern}' (#{results.size} #{results.size == 1 ? "entry" : "entries"}, #{total_matches} total #{total_matches == 1 ? "match" : "matches"}):"
+        output << "Memory entries matching #{search_desc} (#{results.size} #{results.size == 1 ? "entry" : "entries"}, #{total_matches} total #{total_matches == 1 ? "match" : "matches"}):"
 
         results.each do |result|
           output << "  memory://#{result[:path]}: #{result[:count]} #{result[:count] == 1 ? "match" : "matches"}"

data/lib/swarm_memory/version.rb

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

data/lib/swarm_sdk/swarm/tool_configurator.rb

@@ -298,7 +298,7 @@ module SwarmSDK
       # Check if a tool should be disabled based on disable_default_tools config
       #
       # @param tool_name [Symbol] Tool name to check
-      # @param disable_config [nil, Boolean, Array<Symbol>] Disable configuration
+      # @param disable_config [nil, Boolean, Symbol, Array<Symbol>] Disable configuration
       # @return [Boolean] True if tool should be disabled
       def tool_disabled?(tool_name, disable_config)
         return false if disable_config.nil?
@@ -306,6 +306,9 @@ module SwarmSDK
         if disable_config == true
           # Disable all default tools
           true
+        elsif disable_config.is_a?(Symbol)
+          # Single tool name
+          disable_config == tool_name
         elsif disable_config.is_a?(Array)
           # Disable only tools in the array
           disable_config.include?(tool_name)

data/lib/swarm_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwarmSDK
-  VERSION = "2.0.6"
+  VERSION = "2.1.0"
 end

data/lib/swarm_sdk.rb

@@ -147,15 +147,6 @@ require "ruby_llm/mcp/parameter"
 
 module RubyLLM
   module MCP
-    class Parameter < RubyLLM::Parameter
-      def initialize(name, type: "string", desc: nil, required: true, default: nil, union_type: nil)
-        super(name, type: type, desc: desc, required: required)
-        @properties = {}
-        @union_type = union_type
-        @default = default
-      end
-    end
-
     module Notifications
       class Initialize
         def call

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: swarm_memory
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Paulo Arruda
 bindir: bin
 cert_chain: []
-date: 2025-10-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -307,7 +307,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Persistent memory system for SwarmSDK agents
 test_files: []