claude_swarm 1.0.1 → 1.0.2

data/lib/swarm_memory/tools/memory_read.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module SwarmMemory
+  module Tools
+    # Tool for reading content from memory storage
+    #
+    # Retrieves content stored by this agent using memory_write.
+    # Each agent has its own isolated memory storage.
+    class MemoryRead < RubyLLM::Tool
+      description <<~DESC
+        Read content from your memory storage and retrieve all associated metadata.
+
+        REQUIRED: Provide the file_path parameter - the path to the memory entry you want to read.
+
+        **Parameters:**
+        - file_path (REQUIRED): Path to memory entry - MUST start with concept/, fact/, skill/, or experience/
+
+        **MEMORY STRUCTURE - EXACTLY 4 Top-Level Categories (NEVER create others):**
+        ALL paths MUST start with one of these 4 fixed categories:
+        - concept/{domain}/{name}.md - Abstract ideas (e.g., concept/ruby/classes.md)
+        - fact/{subfolder}/{name}.md - Concrete info (e.g., fact/people/john.md)
+        - skill/{domain}/{name}.md - Procedures (e.g., skill/debugging/api-errors.md)
+        - experience/{name}.md - Lessons (e.g., experience/fixed-bug.md)
+
+        INVALID: documentation/, reference/, tutorial/, parallel/, analysis/, notes/
+
+        **Returns:**
+        JSON with two fields:
+        - content: Markdown content with line numbers (same format as Read tool)
+        - metadata: All metadata (title, type, tags, tools, permissions, confidence, etc.)
+
+        **Examples:**
+        - MemoryRead(file_path: "concept/ruby/classes.md") - Read a concept
+        - MemoryRead(file_path: "fact/people/john.md") - Read a fact
+        - 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
+        - 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
+
+      param :file_path,
+        desc: "Path to read from memory - MUST start with concept/, fact/, skill/, or experience/ (e.g., 'concept/ruby/classes.md', 'skill/debugging/api.md')",
+        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 "MemoryRead"
+      def name
+        "MemoryRead"
+      end
+
+      # Execute the tool
+      #
+      # @param file_path [String] Path to read from
+      # @return [String] JSON with content and metadata
+      def execute(file_path:)
+        # Register this read in the tracker
+        Core::StorageReadTracker.register_read(@agent_name, file_path)
+
+        # Read full entry with metadata
+        entry = @storage.read_entry(file_path: file_path)
+
+        # Always return JSON format (metadata always exists - at minimum title)
+        format_as_json(entry)
+      rescue ArgumentError => e
+        validation_error(e.message)
+      end
+
+      private
+
+      def validation_error(message)
+        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
+      end
+
+      # Format entry as JSON with content and metadata
+      #
+      # Returns a clean JSON format separating content from metadata.
+      # This prevents agents from mimicking metadata format when writing.
+      #
+      # Content includes line numbers (same format as Read tool).
+      # Metadata always includes at least title (from Entry).
+      # Additional metadata comes from the metadata hash (type, tags, tools, etc.)
+      #
+      # @param entry [Core::Entry] Entry with content and metadata
+      # @return [String] Pretty-printed JSON
+      def format_as_json(entry)
+        # Build metadata hash with title included
+        metadata_hash = { "title" => entry.title }
+        metadata_hash.merge!(entry.metadata) if entry.metadata
+
+        result = {
+          content: format_with_line_numbers(entry.content),
+          metadata: metadata_hash,
+        }
+        JSON.pretty_generate(result)
+      end
+
+      # Format content with line numbers (same format as Read tool)
+      #
+      # @param content [String] Content to format
+      # @return [String] Content with line numbers
+      def format_with_line_numbers(content)
+        lines = content.lines
+        output_lines = lines.each_with_index.map do |line, idx|
+          line_number = idx + 1
+          display_line = line.chomp
+          "#{line_number.to_s.rjust(6)}→#{display_line}"
+        end
+        output_lines.join("\n")
+      end
+    end
+  end
+end

data/lib/swarm_memory/tools/memory_write.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module SwarmMemory
+  module Tools
+    # Tool for writing content to memory storage
+    #
+    # Stores content and metadata in persistent, per-agent memory storage.
+    # Each agent has its own isolated memory storage that persists across sessions.
+    class MemoryWrite < RubyLLM::Tool
+      description <<~DESC
+        Store content in persistent memory with structured metadata for semantic search and retrieval.
+
+        IMPORTANT: Content must be 250 words or less. If content exceeds this limit, extract key entities: concepts, experiences, facts, skills,
+        then split into multiple focused memories (each under 250 words) that capture ALL important details.
+        Link related memories using the 'related' metadata field with memory:// URIs.
+
+        CRITICAL: ALL 8 required parameters MUST be provided. Do NOT skip any. If you're missing information, ask the user or infer reasonable defaults.
+
+        REQUIRED PARAMETERS (provide ALL 8):
+        1. file_path - Where to store (e.g., 'concept/ruby/classes.md', 'skill/debugging/trace-errors.md')
+        2. content - Pure markdown content (no frontmatter)
+        3. title - Brief descriptive title
+        4. type - Entry category: "concept", "fact", "skill", or "experience"
+        5. confidence - How sure you are: "high", "medium", or "low"
+        6. tags - JSON string of array of search keywords (e.g., '["ruby", "classes", "oop"]') - be comprehensive!
+        7. related - JSON string of array of related memory paths (e.g., '["memory://concept/ruby/modules.md", "memory://concept/ruby/classes.md"]') or '[]' if none
+        8. domain - Category like 'programming/ruby', 'people', 'debugging'
+        9. source - Where this came from: "user", "documentation", "experimentation", or "inference"
+
+        OPTIONAL (for skills only):
+        - tools - JSON string of array of tool names needed (e.g., '["Read", "Edit", "Bash"]') or '[]' if none
+        - permissions - Tool restrictions hash or {}
+
+        PATH STRUCTURE (EXACTLY 4 TOP-LEVEL CATEGORIES - NEVER CREATE OTHERS):
+        Memory has EXACTLY 4 fixed top-level categories. ALL paths MUST start with one of these:
+
+        1. concept/{domain}/{name}.md - Abstract ideas (e.g., concept/ruby/classes.md)
+        2. fact/{subfolder}/{name}.md - Concrete info (e.g., fact/people/john.md)
+        3. skill/{domain}/{name}.md - How-to procedures (e.g., skill/debugging/api-errors.md)
+        4. experience/{name}.md - Lessons learned (e.g., experience/fixed-cors-bug.md)
+
+        INVALID (do NOT create): documentation/, reference/, tutorial/, knowledge/, notes/
+        These categories do NOT exist. Use concept/, fact/, skill/, or experience/ instead.
+
+        TAGS ARE CRITICAL: Think "What would I search for in 6 months?" For skills especially, be VERY comprehensive with tags - they're your search index.
+
+        EXAMPLES:
+        - For concept: tags: ['ruby', 'oop', 'classes', 'inheritance', 'methods']
+        - For skill: tags: ['debugging', 'api', 'http', 'errors', 'trace', 'network', 'rest']
+      DESC
+
+      param :file_path,
+        desc: "Path with .md extension (e.g., 'concept/ruby/classes.md', 'fact/people/john.md')",
+        required: true
+
+      param :content,
+        desc: "Content to store (pure markdown, no frontmatter needed)",
+        required: true
+
+      param :title,
+        desc: "Brief title describing the content",
+        required: true
+
+      # Metadata parameters (stored in .yml sidecar)
+      param :type,
+        desc: "Entry type: concept, fact, skill, or experience (matches category: concept/, fact/, skill/, experience/)",
+        required: true
+
+      param :confidence,
+        desc: "Confidence level: high, medium, or low (defaults to 'medium' if not specified)",
+        required: false
+
+      param :tags,
+        type: "string",
+        desc: "JSON string of array of tag strings for searching (e.g., '[\"ruby\", \"oop\"]')",
+        required: true
+
+      param :related,
+        type: "string",
+        desc: "JSON string of array of related memory path strings (e.g., '[\"memory://concept/ruby/modules.md\", \"memory://concept/ruby/classes.md\"]')",
+        required: true
+
+      param :domain,
+        desc: "Category/subcategory (e.g., 'programming/ruby', 'people')",
+        required: true
+
+      param :source,
+        desc: "Source of information: user, documentation, experimentation, or inference (defaults to 'user' if not specified)",
+        required: false
+
+      param :tools,
+        type: "string",
+        desc: "JSON string of array of tool name strings required for this skill (e.g., '[\"Read\", \"Edit\", \"Bash\"]'). Only for type: skill",
+        required: false
+
+      param :permissions,
+        type: "object",
+        desc: "Tool permission restrictions (same format as swarm config). Only for type: skill",
+        required: false
+
+      # Initialize with storage instance
+      #
+      # @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 "MemoryWrite"
+      def name
+        "MemoryWrite"
+      end
+
+      # Execute the tool
+      #
+      # @param file_path [String] Path to store content (.md file)
+      # @param content [String] Content to store (pure markdown)
+      # @param title [String] Brief title
+      # @param type [String, nil] Entry type
+      # @param confidence [String, nil] Confidence level
+      # @param tags [Array, nil] Tags
+      # @param related [Array, nil] Related paths
+      # @param domain [String, nil] Domain
+      # @param source [String, nil] Source
+      # @param tools [Array, nil] Tools required (for skills)
+      # @param permissions [Hash, nil] Tool permissions (for skills)
+      # @return [String] Success message
+      def execute(
+        file_path:,
+        content:,
+        title:,
+        type:,
+        confidence: nil,
+        tags:,
+        related:,
+        domain:,
+        source: nil,
+        tools: nil,
+        permissions: nil
+      )
+        # Validate content length (250 word limit)
+        word_count = content.split(/\s+/).size
+        if word_count > 250
+          return validation_error(
+            "Content exceeds 250-word limit (#{word_count} words). " \
+              "Please extract the key entities and concepts from this content, then split it into multiple smaller, " \
+              "focused memories (each under 250 words) that still capture ALL the important details. " \
+              "Link related memories together using the 'related' metadata field with memory:// URIs. " \
+              "Each memory should cover one specific aspect or concept while preserving completeness.",
+          )
+        end
+
+        # Build metadata hash from params
+        # Handle both JSON strings (from LLMs) and Ruby arrays (from tests/code)
+        metadata = {}
+        metadata["type"] = type if type
+        metadata["confidence"] = confidence || "medium" # Default to medium
+        metadata["tags"] = parse_array_param(tags) if tags
+        metadata["related"] = parse_array_param(related) if related
+        metadata["domain"] = domain if domain
+        metadata["source"] = source || "user" # Default to user
+        metadata["tools"] = parse_array_param(tools) if tools
+        metadata["permissions"] = parse_object_param(permissions) if permissions
+
+        # Write to storage (metadata passed separately, not in content)
+        entry = @storage.write(
+          file_path: file_path,
+          content: content,
+          title: title,
+          metadata: metadata,
+        )
+
+        "Stored at memory://#{file_path} (#{format_bytes(entry.size)})"
+      rescue ArgumentError => e
+        validation_error(e.message)
+      rescue JSON::ParserError => e
+        validation_error("Invalid tool parameter JSON format: #{e.message}")
+      end
+
+      private
+
+      def validation_error(message)
+        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
+      end
+
+      # Parse array parameter (handles both JSON strings and Ruby arrays)
+      #
+      # @param value [String, Array] JSON string or Ruby array
+      # @return [Array] Parsed array
+      def parse_array_param(value)
+        return value if value.is_a?(Array)
+        return [] if value.nil? || value.to_s.strip.empty?
+
+        JSON.parse(value)
+      end
+
+      # Parse object parameter (handles both JSON strings and Ruby hashes)
+      #
+      # @param value [String, Hash] JSON string or Ruby hash
+      # @return [Hash] Parsed hash
+      def parse_object_param(value)
+        return value if value.is_a?(Hash)
+        return {} if value.nil? || value.to_s.strip.empty?
+
+        begin
+          JSON.parse(value)
+        rescue JSON::ParserError => e
+          # Handle common JSON errors gracefully
+          warn("Warning: Failed to parse object parameter: #{e.message}. Returning empty object.")
+          {}
+        end
+      end
+
+      # Format bytes to human-readable size
+      #
+      # @param bytes [Integer] Number of bytes
+      # @return [String] Formatted size
+      def format_bytes(bytes)
+        if bytes >= 1_000_000
+          "#{(bytes.to_f / 1_000_000).round(1)}MB"
+        elsif bytes >= 1_000
+          "#{(bytes.to_f / 1_000).round(1)}KB"
+        else
+          "#{bytes}B"
+        end
+      end
+    end
+  end
+end

data/lib/swarm_memory/utils.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SwarmMemory
+  # Shared utility methods for SwarmMemory
+  module Utils
+    class << self
+      # Recursively convert all hash keys to strings
+      #
+      # Handles nested hashes and arrays containing hashes.
+      #
+      # @param obj [Object] Object to stringify (Hash, Array, or other)
+      # @return [Object] Object with stringified keys (if applicable)
+      #
+      # @example
+      #   Utils.stringify_keys({ name: "test", config: { key: "value" } })
+      #   # => { "name" => "test", "config" => { "key" => "value" } }
+      def stringify_keys(obj)
+        case obj
+        when Hash
+          obj.transform_keys(&:to_s).transform_values { |v| stringify_keys(v) }
+        when Array
+          obj.map { |item| stringify_keys(item) }
+        else
+          obj
+        end
+      end
+
+      # Recursively convert all hash keys to symbols
+      #
+      # Handles nested hashes and arrays containing hashes.
+      #
+      # @param obj [Object] Object to symbolize (Hash, Array, or other)
+      # @return [Object] Object with symbolized keys (if applicable)
+      #
+      # @example
+      #   Utils.symbolize_keys({ "name" => "test", "config" => { "key" => "value" } })
+      #   # => { name: "test", config: { key: "value" } }
+      def symbolize_keys(obj)
+        case obj
+        when Hash
+          obj.transform_keys(&:to_sym).transform_values { |v| symbolize_keys(v) }
+        when Array
+          obj.map { |item| symbolize_keys(item) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/swarm_memory/version.rb

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

data/lib/swarm_memory.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+# Load dependencies first (before Zeitwerk)
+require "json"
+require "yaml"
+require "fileutils"
+require "time"
+require "date"
+require "set"
+
+require "async"
+require "async/semaphore"
+require "swarm_sdk"
+require "ruby_llm"
+
+# Try to load informers (optional, for embeddings)
+begin
+  require "informers"
+rescue LoadError
+  # Informers not available - embeddings will be disabled
+  warn("Warning: informers gem not found. Semantic search will be unavailable. Run: gem install informers")
+end
+
+# Load errors and version first
+require_relative "swarm_memory/errors"
+require_relative "swarm_memory/version"
+
+# Setup Zeitwerk loader
+require "zeitwerk"
+loader = Zeitwerk::Loader.new
+loader.push_dir("#{__dir__}/swarm_memory", namespace: SwarmMemory)
+loader.setup
+
+# Explicitly load DSL components and extensions to inject into SwarmSDK
+# These must be loaded after Zeitwerk but before anything uses them
+require_relative "swarm_memory/dsl/memory_config"
+require_relative "swarm_memory/dsl/builder_extension"
+require_relative "swarm_memory/chat_extension"
+
+module SwarmMemory
+  class << self
+    # Registry for custom adapters
+    def adapter_registry
+      @adapter_registry ||= {}
+    end
+
+    # Register a custom adapter
+    #
+    # @param name [Symbol] Adapter name
+    # @param klass [Class] Adapter class (must inherit from Adapters::Base)
+    #
+    # @example
+    #   SwarmMemory.register_adapter(:activerecord, ActiveRecordMemoryAdapter)
+    def register_adapter(name, klass)
+      unless klass < Adapters::Base
+        raise ArgumentError, "Adapter must inherit from SwarmMemory::Adapters::Base"
+      end
+
+      adapter_registry[name.to_sym] = klass
+    end
+
+    # Get adapter class by name
+    #
+    # @param name [Symbol] Adapter name
+    # @return [Class] Adapter class
+    # @raise [ArgumentError] If adapter is not found
+    def adapter_for(name)
+      name = name.to_sym
+
+      # Check built-in adapters first
+      case name
+      when :filesystem
+        Adapters::FilesystemAdapter
+      else
+        # Check registry
+        adapter_registry[name] || raise(ArgumentError, "Unknown adapter: #{name}. Available: #{available_adapters.join(", ")}")
+      end
+    end
+
+    # Get list of available adapters
+    #
+    # @return [Array<Symbol>] List of registered adapter names
+    def available_adapters
+      [:filesystem] + adapter_registry.keys
+    end
+
+    # Create individual tool instance
+    # Called by SwarmSDK's ToolConfigurator
+    #
+    # @param tool_name [Symbol] Tool name
+    # @param storage [SwarmMemory::Core::Storage] Storage instance
+    # @param agent_name [String, Symbol] Agent identifier
+    # @param options [Hash] Additional options for special tools like LoadSkill
+    # @option options [SwarmSDK::Agent::Chat] :chat Chat instance (for LoadSkill)
+    # @option options [SwarmSDK::ToolConfigurator] :tool_configurator Tool configurator (for LoadSkill)
+    # @option options [SwarmSDK::Agent::Definition] :agent_definition Agent definition (for LoadSkill)
+    # @return [RubyLLM::Tool] Configured tool instance
+    def create_tool(tool_name, storage:, agent_name:, **options)
+      # Validate storage is present
+      if storage.nil?
+        raise ConfigurationError,
+          "Cannot create #{tool_name} tool: memory storage is nil. " \
+            "Did you configure memory for this agent? " \
+            "Add: memory { directory '.swarm/agent-memory' }"
+      end
+
+      case tool_name.to_sym
+      when :MemoryWrite
+        Tools::MemoryWrite.new(storage: storage, agent_name: agent_name)
+      when :MemoryRead
+        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
+        Tools::MemoryGlob.new(storage: storage)
+      when :MemoryGrep
+        Tools::MemoryGrep.new(storage: storage)
+      when :MemoryDefrag
+        Tools::MemoryDefrag.new(storage: storage)
+      when :LoadSkill
+        # LoadSkill requires additional context for tool swapping
+        Tools::LoadSkill.new(
+          storage: storage,
+          agent_name: agent_name,
+          chat: options[:chat],
+          tool_configurator: options[:tool_configurator],
+          agent_definition: options[:agent_definition],
+        )
+      else
+        raise ConfigurationError, "Unknown memory tool: #{tool_name}"
+      end
+    end
+
+    # Convenience method for creating all memory tools at once
+    # Useful for direct RubyLLM usage (not via SwarmSDK)
+    #
+    # @param storage [SwarmMemory::Core::Storage] Storage instance
+    # @param agent_name [String, Symbol] Agent identifier
+    # @return [Array<RubyLLM::Tool>] All configured memory tools
+    def tools_for(storage:, agent_name:)
+      [
+        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),
+        Tools::MemoryDefrag.new(storage: storage),
+      ]
+    end
+  end
+end
+
+# Auto-register with SwarmSDK when loaded
+require_relative "swarm_memory/integration/sdk_plugin"
+require_relative "swarm_memory/integration/registration"
+SwarmMemory::Integration::Registration.register!
+
+# Auto-register CLI commands with SwarmCLI when loaded
+require_relative "swarm_memory/integration/cli_registration"
+SwarmMemory::Integration::CliRegistration.register!