swarm_memory 2.1.2 → 2.1.4

data/lib/swarm_sdk/tools/multi_edit.rb

@@ -11,6 +11,13 @@ module SwarmSDK
     class MultiEdit < RubyLLM::Tool
       include PathResolver
 
+      # Factory pattern: declare what parameters this tool needs for instantiation
+      class << self
+        def creation_requirements
+          [:agent_name, :directory]
+        end
+      end
+
       description <<~DESC
         Performs multiple exact string replacements in a single file.
         Edits are applied sequentially, so later edits see the results of earlier ones.
@@ -53,8 +60,7 @@ module SwarmSDK
       # @param directory [String] Agent's working directory
       def initialize(agent_name:, directory:)
         super()
-        @agent_name = agent_name.to_sym
-        @directory = File.expand_path(directory)
+        initialize_agent_context(agent_name: agent_name, directory: directory)
       end
 
       # Override name to return simple "MultiEdit" instead of full class path
@@ -204,15 +210,13 @@ module SwarmSDK
 
       private
 
-      # Helper methods
-      def validation_error(message)
-        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
-      end
-
-      def error(message)
-        "Error: #{message}"
-      end
-
+      # Format an error that includes partial results
+      #
+      # Shows what edits succeeded before the error occurred.
+      #
+      # @param message [String] Error description
+      # @param results [Array<Hash>] Successful edit results before failure
+      # @return [String] Formatted error message with results summary
       def error_with_results(message, results)
         output = "<tool_use_error>InputValidationError: #{message}\n\n"
 

data/lib/swarm_sdk/tools/path_resolver.rb

@@ -2,7 +2,12 @@
 
 module SwarmSDK
   module Tools
-    # Shared path resolution logic for all file tools
+    # Shared path resolution and agent context logic for file tools
+    #
+    # This module provides:
+    # - Path resolution (relative to agent's working directory)
+    # - Agent context initialization (agent_name, directory expansion)
+    # - Standard error message formatting
     #
     # Tools resolve relative paths against the agent's directory.
     # Absolute paths are used as-is.
@@ -12,17 +17,41 @@ module SwarmSDK
     #     include PathResolver
     #
     #     def initialize(agent_name:, directory:)
-    #       @directory = File.expand_path(directory)
+    #       super()
+    #       initialize_agent_context(agent_name: agent_name, directory: directory)
     #     end
     #
     #     def execute(file_path:)
     #       resolved_path = resolve_path(file_path)
     #       File.read(resolved_path)
+    #     rescue StandardError => e
+    #       error("Failed to read: #{e.message}")
     #     end
     #   end
     module PathResolver
+      # Agent context attributes
+      # @return [Symbol] The agent identifier
+      attr_reader :agent_name
+
+      # @return [String] Absolute path to agent's working directory
+      attr_reader :directory
+
       private
 
+      # Initialize agent context for file tools
+      #
+      # Sets up the common agent context needed by file tools:
+      # - Normalizes agent_name to symbol
+      # - Expands directory to absolute path
+      #
+      # @param agent_name [Symbol, String] The agent identifier
+      # @param directory [String] Agent's working directory (will be expanded)
+      # @return [void]
+      def initialize_agent_context(agent_name:, directory:)
+        @agent_name = agent_name.to_sym
+        @directory = File.expand_path(directory)
+      end
+
       # Resolve a path relative to the agent's directory
       #
       # - Absolute paths (starting with /) are returned as-is
@@ -38,6 +67,26 @@ module SwarmSDK
 
         File.expand_path(path, @directory)
       end
+
+      # Format a validation error response
+      #
+      # Used for input validation failures (missing required params, invalid formats, etc.)
+      #
+      # @param message [String] Error description
+      # @return [String] Formatted error message wrapped in tool_use_error tags
+      def validation_error(message)
+        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
+      end
+
+      # Format a general error response
+      #
+      # Used for runtime errors (permission denied, file not found, etc.)
+      #
+      # @param message [String] Error description
+      # @return [String] Formatted error message prefixed with "Error:"
+      def error(message)
+        "Error: #{message}"
+      end
     end
   end
 end

data/lib/swarm_sdk/tools/read.rb

@@ -10,8 +10,9 @@ module SwarmSDK
     class Read < RubyLLM::Tool
       include PathResolver
 
-      MAX_LINE_LENGTH = 2000
-      DEFAULT_LIMIT = 2000
+      # Backward compatibility aliases - use Defaults module for new code
+      MAX_LINE_LENGTH = Defaults::Limits::LINE_CHARACTERS
+      DEFAULT_LIMIT = Defaults::Limits::READ_LINES
 
       # List of available document converters
       CONVERTERS = [
@@ -28,6 +29,13 @@ module SwarmSDK
         ""
       end
 
+      # Factory pattern: declare what parameters this tool needs for instantiation
+      class << self
+        def creation_requirements
+          [:agent_name, :directory]
+        end
+      end
+
       description <<~DESC
         Reads a file from the local filesystem. You can access any file directly by using this tool.
         Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid.
@@ -67,8 +75,7 @@ module SwarmSDK
       # @param directory [String] Agent's working directory
       def initialize(agent_name:, directory:)
         super()
-        @agent_name = agent_name.to_sym
-        @directory = File.expand_path(directory)
+        initialize_agent_context(agent_name: agent_name, directory: directory)
       end
 
       # Override name to return simple "Read" instead of full class path
@@ -92,25 +99,37 @@ module SwarmSDK
           return validation_error("Path is a directory, not a file. Use Bash with ls to read directories.")
         end
 
-        # Register this read in the tracker (use resolved path)
-        Stores::ReadTracker.register_read(@agent_name, resolved_path)
-
         # Check if it's a document and try to convert it
         converter = find_converter_for_file(resolved_path)
         if converter
           result = converter.new.convert(resolved_path)
+          # For document files, register the converted text content
+          # Extract text from result (may be wrapped in system-reminder tags)
+          if result.is_a?(String)
+            # Remove system-reminder wrapper if present to get clean text for digest
+            text_content = result.gsub(%r{<system-reminder>.*?</system-reminder>}m, "").strip
+            Stores::ReadTracker.register_read(@agent_name, resolved_path, text_content)
+          end
           return result
         end
 
         # Try to read as text, handle binary files separately
         content = read_file_content(resolved_path)
 
-        # If content is a Content object (binary file), return it directly
-        return content if content.is_a?(RubyLLM::Content)
+        # If content is a Content object (binary file), track with binary digest and return
+        if content.is_a?(RubyLLM::Content)
+          # For binary files, read raw bytes for digest
+          binary_content = File.binread(resolved_path)
+          Stores::ReadTracker.register_read(@agent_name, resolved_path, binary_content)
+          return content
+        end
 
         # Return early if we got an error message or system reminder
         return content if content.is_a?(String) && (content.start_with?("Error:") || content.start_with?("<system-reminder>"))
 
+        # At this point, we have valid text content - register the read with digest
+        Stores::ReadTracker.register_read(@agent_name, resolved_path, content)
+
         # Check if file is empty
         if content.empty?
           return format_with_reminder(
@@ -170,15 +189,6 @@ module SwarmSDK
         CONVERTERS.find { |converter| converter.extensions.include?(ext) }
       end
 
-      # Helper methods
-      def validation_error(message)
-        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
-      end
-
-      def error(message)
-        "Error: #{message}"
-      end
-
       def format_with_reminder(content, reminder)
         return content if reminder.nil? || reminder.empty?
 

data/lib/swarm_sdk/tools/registry.rb

@@ -5,24 +5,51 @@ module SwarmSDK
     # Registry for built-in SwarmSDK tools
     #
     # Maps tool names (symbols) to their RubyLLM::Tool classes.
-    # Provides validation and lookup functionality for tool registration.
+    # Provides validation, lookup, and factory functionality for tool registration.
+    #
+    # ## Tool Creation Pattern
+    #
+    # Tools register themselves with their creation requirements via the `tool_factory` method.
+    # This eliminates the need for a giant case statement in ToolConfigurator.
+    #
+    # Tools fall into three categories:
+    # 1. **No params**: Simple tools with no initialization requirements (Think, Clock)
+    # 2. **Directory only**: Tools needing working directory (Bash, Grep, Glob)
+    # 3. **Agent context**: Tools needing agent tracking (Read, Write, Edit, MultiEdit)
+    # 4. **Scratchpad**: Tools needing scratchpad storage instance
+    #
+    # @example Adding a new tool with creation requirements
+    #   # In the tool class:
+    #   class MyTool < RubyLLM::Tool
+    #     def self.creation_requirements
+    #       [:agent_name, :directory]
+    #     end
+    #   end
+    #
+    #   # In registry:
+    #   BUILTIN_TOOLS = {
+    #     MyTool: SwarmSDK::Tools::MyTool,
+    #   }
     #
     # Note: Plugin-provided tools (e.g., memory tools) are NOT in this registry.
     # They are registered via SwarmSDK::PluginRegistry instead.
     class Registry
       # All available built-in tools
+      #
+      # Maps tool names to their classes. The class must respond to `creation_requirements`
+      # to specify what parameters are needed for instantiation.
       BUILTIN_TOOLS = {
-        Read: :special, # Requires agent context for read tracking
-        Write: :special, # Requires agent context for read-before-write enforcement
-        Edit: :special, # Requires agent context for read-before-edit enforcement
+        Read: SwarmSDK::Tools::Read,
+        Write: SwarmSDK::Tools::Write,
+        Edit: SwarmSDK::Tools::Edit,
+        MultiEdit: SwarmSDK::Tools::MultiEdit,
         Bash: SwarmSDK::Tools::Bash,
         Grep: SwarmSDK::Tools::Grep,
         Glob: SwarmSDK::Tools::Glob,
-        MultiEdit: :special, # Requires agent context for read-before-edit enforcement
-        TodoWrite: :special, # Requires agent context for todo tracking
-        ScratchpadWrite: :special, # Requires scratchpad storage instance
-        ScratchpadRead: :special, # Requires scratchpad storage instance
-        ScratchpadList: :special, # Requires scratchpad storage instance
+        TodoWrite: SwarmSDK::Tools::TodoWrite,
+        ScratchpadWrite: :scratchpad, # Requires scratchpad storage instance
+        ScratchpadRead: :scratchpad,  # Requires scratchpad storage instance
+        ScratchpadList: :scratchpad,  # Requires scratchpad storage instance
         Think: SwarmSDK::Tools::Think,
         WebFetch: SwarmSDK::Tools::WebFetch,
         Clock: SwarmSDK::Tools::Clock,
@@ -35,12 +62,49 @@ module SwarmSDK
         # They are managed by SwarmSDK::PluginRegistry instead.
         #
         # @param name [Symbol, String] Tool name
-        # @return [Class, Symbol, nil] Tool class, :special, or nil if not found
+        # @return [Class, Symbol, nil] Tool class, :scratchpad marker, or nil if not found
         def get(name)
           name_sym = name.to_sym
           BUILTIN_TOOLS[name_sym]
         end
 
+        # Create a tool instance using the Factory Pattern
+        #
+        # Uses the tool's `creation_requirements` class method to determine
+        # what parameters to pass to the constructor.
+        #
+        # @param name [Symbol, String] Tool name
+        # @param context [Hash] Available context for tool creation
+        # @option context [Symbol] :agent_name Agent identifier
+        # @option context [String] :directory Agent's working directory
+        # @option context [Object] :scratchpad_storage Scratchpad storage instance
+        # @return [RubyLLM::Tool] Instantiated tool
+        # @raise [ConfigurationError] If tool is unknown or has unmet requirements
+        def create(name, context = {})
+          name_sym = name.to_sym
+          tool_entry = BUILTIN_TOOLS[name_sym]
+
+          raise ConfigurationError, "Unknown tool: #{name}" unless tool_entry
+
+          # Handle scratchpad tools specially (they use factory methods)
+          if tool_entry == :scratchpad
+            return create_scratchpad_tool(name_sym, context[:scratchpad_storage])
+          end
+
+          # Get the tool class and its requirements
+          tool_class = tool_entry
+
+          # Check if tool defines creation requirements
+          if tool_class.respond_to?(:creation_requirements)
+            requirements = tool_class.creation_requirements
+            params = extract_params(requirements, context, name)
+            tool_class.new(**params)
+          else
+            # No requirements - simple instantiation
+            tool_class.new
+          end
+        end
+
         # Get multiple tool classes by names
         #
         # @param names [Array<Symbol, String>] Tool names
@@ -87,6 +151,54 @@ module SwarmSDK
         def validate(names)
           names.reject { |name| exists?(name) }
         end
+
+        private
+
+        # Extract required parameters from context
+        #
+        # @param requirements [Array<Symbol>] Required parameter names
+        # @param context [Hash] Available context
+        # @param tool_name [Symbol] Tool name for error messages
+        # @return [Hash] Parameters to pass to tool constructor
+        # @raise [ConfigurationError] If required parameter is missing
+        def extract_params(requirements, context, tool_name)
+          params = {}
+
+          requirements.each do |req|
+            unless context.key?(req)
+              raise ConfigurationError,
+                "Tool #{tool_name} requires #{req} but it was not provided in context"
+            end
+
+            params[req] = context[req]
+          end
+
+          params
+        end
+
+        # Create a scratchpad tool using its factory method
+        #
+        # @param name [Symbol] Scratchpad tool name
+        # @param storage [Object] Scratchpad storage instance
+        # @return [RubyLLM::Tool] Instantiated scratchpad tool
+        # @raise [ConfigurationError] If storage is not provided
+        def create_scratchpad_tool(name, storage)
+          unless storage
+            raise ConfigurationError,
+              "Scratchpad tool #{name} requires scratchpad_storage in context"
+          end
+
+          case name
+          when :ScratchpadWrite
+            Tools::Scratchpad::ScratchpadWrite.create_for_scratchpad(storage)
+          when :ScratchpadRead
+            Tools::Scratchpad::ScratchpadRead.create_for_scratchpad(storage)
+          when :ScratchpadList
+            Tools::Scratchpad::ScratchpadList.create_for_scratchpad(storage)
+          else
+            raise ConfigurationError, "Unknown scratchpad tool: #{name}"
+          end
+        end
       end
     end
   end

data/lib/swarm_sdk/tools/scratchpad/scratchpad_list.rb

@@ -12,8 +12,29 @@ module SwarmSDK
 
         description <<~DESC
           List all entries in scratchpad with their metadata.
-          Shows path, title, size, and last updated time for each entry.
-          Use this to discover what's stored in the scratchpad.
+
+          ## When to Use ScratchpadList
+
+          Use ScratchpadList to:
+          - Discover what content is available in the scratchpad
+          - Check what other agents have stored
+          - Find relevant entries before reading them
+          - Review all stored outputs and analysis
+          - Check entry sizes and last update times
+
+          ## Best Practices
+
+          - Use this before ScratchpadRead if you don't know what's stored
+          - Filter by prefix to narrow down results (e.g., 'notes/' lists all notes)
+          - Shows path, title, size, and last updated time for each entry
+          - Any agent can see all scratchpad entries
+          - Helps coordinate multi-agent workflows
+
+          ## Examples
+
+          - List all entries: (no prefix parameter)
+          - List notes only: prefix='notes/'
+          - List analysis results: prefix='analysis/'
         DESC
 
         param :prefix,

data/lib/swarm_sdk/tools/scratchpad/scratchpad_read.rb

@@ -12,8 +12,29 @@ module SwarmSDK
 
         description <<~DESC
           Read content from scratchpad.
-          Use this to retrieve temporary notes, results, or messages stored by any agent.
-          Any agent can read any scratchpad content.
+
+          ## When to Use ScratchpadRead
+
+          Use ScratchpadRead to:
+          - Retrieve previously stored content and outputs
+          - Access detailed analysis or results from earlier steps
+          - Read messages or notes left by other agents
+          - Access cached computed data
+          - Retrieve content that was too long for direct responses
+
+          ## Best Practices
+
+          - Any agent can read any scratchpad content
+          - Content is returned with line numbers for easy reference
+          - Use ScratchpadList first if you don't know what's stored
+          - Scratchpad data is temporary and lost when swarm ends
+          - For persistent data, use MemoryRead instead
+
+          ## Examples
+
+          - Read status: file_path='status'
+          - Read analysis: file_path='api_analysis'
+          - Read agent notes: file_path='notes/backend'
         DESC
 
         param :file_path,

data/lib/swarm_sdk/tools/scratchpad/scratchpad_write.rb

@@ -13,12 +13,29 @@ module SwarmSDK
 
         description <<~DESC
           Store content in scratchpad for temporary cross-agent communication.
-          Use this for quick notes, intermediate results, or coordination messages.
-          Any agent can read this content. Data is lost when the swarm ends.
 
-          For persistent storage that survives across sessions, use MemoryWrite instead.
+          ## When to Use Scratchpad
 
-          Choose a simple, descriptive path. Examples: 'status', 'result', 'notes/agent_x'
+          Use ScratchpadWrite to:
+          - Store detailed outputs, analysis, or results that are too long for direct responses
+          - Share information that would otherwise clutter your responses
+          - Store intermediate results during multi-step tasks
+          - Leave coordination messages for other agents
+          - Cache computed data for quick retrieval
+
+          ## Best Practices
+
+          - Choose simple, descriptive paths: 'status', 'result', 'notes/agent_x'
+          - Use hierarchical paths for organization: 'analysis/step1', 'analysis/step2'
+          - Keep entries focused - one piece of information per entry
+          - Any agent can read scratchpad content
+          - Data is lost when the swarm ends (use MemoryWrite for persistent storage)
+          - Maximum 1MB per entry
+
+          ## Examples
+
+          Good paths: 'status', 'api_analysis', 'test_results', 'notes/backend'
+          Bad paths: 'scratch/temp/file123.txt', 'output.log'
         DESC
 
         param :file_path,

data/lib/swarm_sdk/tools/stores/read_tracker.rb

@@ -3,39 +3,74 @@
 module SwarmSDK
   module Tools
     module Stores
-      # ReadTracker manages read-file tracking for all agents
+      # ReadTracker manages read-file tracking for all agents with content digest verification
       #
       # This module maintains a global registry of which files each agent has read
-      # during their conversation. This enables enforcement of the "read-before-write"
-      # and "read-before-edit" rules that ensure agents have context before modifying files.
+      # during their conversation along with SHA256 digests of the content. This enables
+      # enforcement of the "read-before-write" and "read-before-edit" rules that ensure
+      # agents have context before modifying files, AND prevents editing files that have
+      # changed externally since being read.
       #
-      # Each agent maintains an independent set of read files, keyed by agent identifier.
+      # Each agent maintains an independent map of read files to content digests.
       module ReadTracker
-        @read_files = {}
+        @read_files = {} # { agent_id => { file_path => sha256_digest } }
         @mutex = Mutex.new
 
         class << self
-          # Register that an agent has read a file
+          # Register that an agent has read a file with content digest
           #
           # @param agent_id [Symbol] The agent identifier
           # @param file_path [String] The absolute path to the file
-          def register_read(agent_id, file_path)
+          # @param content [String] File content (for digest calculation)
+          # @return [String] The calculated SHA256 digest
+          def register_read(agent_id, file_path, content)
             @mutex.synchronize do
-              @read_files[agent_id] ||= Set.new
-              @read_files[agent_id] << File.expand_path(file_path)
+              @read_files[agent_id] ||= {}
+              digest = Digest::SHA256.hexdigest(content)
+              @read_files[agent_id][File.expand_path(file_path)] = digest
+              digest
             end
           end
 
-          # Check if an agent has read a file
+          # Check if an agent has read a file AND content hasn't changed
           #
           # @param agent_id [Symbol] The agent identifier
           # @param file_path [String] The absolute path to the file
-          # @return [Boolean] true if the agent has read this file
+          # @return [Boolean] true if agent read file and content matches
           def file_read?(agent_id, file_path)
             @mutex.synchronize do
               return false unless @read_files[agent_id]
 
-              @read_files[agent_id].include?(File.expand_path(file_path))
+              expanded_path = File.expand_path(file_path)
+              stored_digest = @read_files[agent_id][expanded_path]
+              return false unless stored_digest
+
+              # Check if file still exists and matches stored digest
+              return false unless File.exist?(expanded_path)
+
+              current_digest = Digest::SHA256.hexdigest(File.read(expanded_path))
+              current_digest == stored_digest
+            end
+          end
+
+          # Get all read files with digests for snapshot
+          #
+          # @param agent_id [Symbol] The agent identifier
+          # @return [Hash] { file_path => digest }
+          def get_read_files(agent_id)
+            @mutex.synchronize do
+              @read_files[agent_id]&.dup || {}
+            end
+          end
+
+          # Restore read files with digests from snapshot
+          #
+          # @param agent_id [Symbol] The agent identifier
+          # @param files_with_digests [Hash] { file_path => digest }
+          # @return [void]
+          def restore_read_files(agent_id, files_with_digests)
+            @mutex.synchronize do
+              @read_files[agent_id] = files_with_digests.dup
             end
           end
 

data/lib/swarm_sdk/tools/stores/scratchpad_storage.rb

@@ -15,10 +15,13 @@ module SwarmSDK
       # Use for temporary, cross-agent communication within a single session.
       class ScratchpadStorage < Storage
         # Initialize scratchpad storage (always volatile)
-        def initialize
+        #
+        # @param total_size_limit [Integer, nil] Maximum total size in bytes (defaults to Defaults::Storage::TOTAL_SIZE_BYTES)
+        def initialize(total_size_limit: nil)
           super() # Initialize parent Storage class
           @entries = {}
           @total_size = 0
+          @total_size_limit = total_size_limit || Defaults::Storage::TOTAL_SIZE_BYTES
           @mutex = Mutex.new
         end
 
@@ -38,8 +41,8 @@ module SwarmSDK
             content_size = content.bytesize
 
             # Check entry size limit
-            if content_size > MAX_ENTRY_SIZE
-              raise ArgumentError, "Content exceeds maximum size (#{format_bytes(MAX_ENTRY_SIZE)}). " \
+            if content_size > Defaults::Storage::ENTRY_SIZE_BYTES
+              raise ArgumentError, "Content exceeds maximum size (#{format_bytes(Defaults::Storage::ENTRY_SIZE_BYTES)}). " \
                 "Current: #{format_bytes(content_size)}"
             end
 
@@ -49,8 +52,8 @@ module SwarmSDK
             new_total_size = @total_size - existing_size + content_size
 
             # Check total size limit
-            if new_total_size > MAX_TOTAL_SIZE
-              raise ArgumentError, "Scratchpad full (#{format_bytes(MAX_TOTAL_SIZE)} limit). " \
+            if new_total_size > @total_size_limit
+              raise ArgumentError, "Scratchpad full (#{format_bytes(@total_size_limit)} limit). " \
                 "Current: #{format_bytes(@total_size)}, " \
                 "Would be: #{format_bytes(new_total_size)}. " \
                 "Clear old entries or use smaller content."
@@ -218,6 +221,51 @@ module SwarmSDK
         def size
           @entries.size
         end
+
+        # Get all entries with content for snapshot
+        #
+        # Thread-safe method that returns a copy of all entries.
+        # Used by snapshot/restore functionality.
+        #
+        # @return [Hash] { path => Entry }
+        def all_entries
+          @mutex.synchronize do
+            @entries.dup
+          end
+        end
+
+        # Restore entries from snapshot
+        #
+        # Restores entries directly without using write() to preserve timestamps.
+        # This ensures entry ordering and metadata accuracy after restore.
+        #
+        # @param entries_data [Hash] { path => { content:, title:, updated_at:, size: } }
+        # @return [void]
+        def restore_entries(entries_data)
+          @mutex.synchronize do
+            entries_data.each do |path, data|
+              # Handle both symbol and string keys from JSON
+              content = data[:content] || data["content"]
+              title = data[:title] || data["title"]
+              updated_at_str = data[:updated_at] || data["updated_at"]
+
+              # Parse timestamp from ISO8601 string
+              updated_at = Time.parse(updated_at_str)
+
+              # Create entry with preserved timestamp
+              entry = Entry.new(
+                content: content,
+                title: title,
+                updated_at: updated_at,
+                size: content.bytesize,
+              )
+
+              # Update storage
+              @entries[path] = entry
+              @total_size += entry.size
+            end
+          end
+        end
       end
     end
   end

data/lib/swarm_sdk/tools/stores/storage.rb

@@ -14,12 +14,6 @@ module SwarmSDK
       # - Search capabilities: Glob patterns and grep-style content search
       # - Thread-safe: Mutex-protected operations
       class Storage
-        # Maximum size per entry (1MB)
-        MAX_ENTRY_SIZE = 1_000_000
-
-        # Maximum total storage size (100MB)
-        MAX_TOTAL_SIZE = 100_000_000
-
         # Represents a single storage entry with metadata
         Entry = Struct.new(:content, :title, :updated_at, :size, keyword_init: true)