swarm_memory 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cc16f06662bd282f8c296aeb6600f53dd80d14f27afad26b9da6f724916d20a
-  data.tar.gz: 6acf6425bdc544f125826ac5ba1f6b127f9c3d96e7ba067712cd15f165ac5af5
+  metadata.gz: 38d427a70039bc09a7a1bbad5a0f2c9f28e46d80a954587ab27f04ad33c66e2f
+  data.tar.gz: 3942488b1873520a984493c6270085b0f6f2e0e01560bea349903463d01bda11
 SHA512:
-  metadata.gz: 91b645763ed45723d82080fb2321ca5e9c0d61310c3f3907843c9086980f5b27e0176315b2ac399f837191c5559b6e36563e2f71bb18adaf2a93a957f186a2e9
-  data.tar.gz: 9b019e85c71c3f7c9f1c1ac5358c53566b5c5934fb1e983087e9c6ebdd81c79b1e32c100d762161bda4aff2227c2be24bfa3d9f0784edc7cbd227a9a21d724af
+  metadata.gz: 945735c0d60be12edc1452ea84059f6a3d6aa68966e687a81d2c8ccbd2492c5b2bdd9099fc4a14c40aaabd1d275cec0a80b35be8c9f5354d217467136493ec57
+  data.tar.gz: f5b0680131c7d38ff229da49031628356c44c4edcb90685b7489e2bc2b30a6d361babf55d3e995d5f28acc62f56b28deaa03829d512f95550dd198b192179df0

data/lib/claude_swarm.rb

@@ -30,13 +30,12 @@ require "thor"
 require "zeitwerk"
 loader = Zeitwerk::Loader.new
 loader.tag = "claude_swarm"
-loader.push_dir("#{__dir__}/claude_swarm", namespace: ClaudeSwarm)
+
 loader.ignore("#{__dir__}/claude_swarm/templates")
 loader.inflector.inflect(
   "cli" => "CLI",
   "openai" => "OpenAI",
 )
-loader.setup
 
 module ClaudeSwarm
   class Error < StandardError; end
@@ -67,3 +66,6 @@ module ClaudeSwarm
     end
   end
 end
+
+loader.push_dir("#{__dir__}/claude_swarm", namespace: ClaudeSwarm)
+loader.setup

data/lib/swarm_cli/version.rb

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

data/lib/swarm_cli.rb

@@ -18,8 +18,7 @@ require "tty/tree"
 
 require "swarm_sdk"
 
-module SwarmCLI
-end
+require_relative "swarm_cli/version"
 
 require "zeitwerk"
 loader = Zeitwerk::Loader.new

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` (1000 words covering everything)
+
+Create multiple linked memories with FULL details in each:
+✅ `concept/payment/processing-flow.md` (250 words) (complete flow with all steps) → related: ["concept/payment/validation.md"]
+✅ `concept/payment/validation.md` (250 words) (all validation rules with specifics) → related: ["concept/payment/processing-flow.md", "concept/payment/error-handling.md"]
+✅ `concept/payment/error-handling.md` (250 words) (all error codes and responses) → related: ["concept/payment/validation.md"]
+✅ `concept/payment/security.md` (250 words) (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.