swarm_memory 2.1.5 → 2.1.6

data/lib/swarm_sdk/configuration.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmSDK
-  # Configuration facade that delegates to Parser and Translator
-  #
-  # This class maintains the public API while internally delegating to:
-  # - Configuration::Parser - YAML parsing, validation, and normalization
-  # - Configuration::Translator - Translation to Swarm/Workflow DSL builders
-  #
-  # ## Public API (unchanged)
-  # - Configuration.load_file(path) - Load from file
-  # - Configuration.new(yaml_content, base_dir:) - Load from string
-  # - config.load_and_validate - Parse and validate
-  # - config.to_swarm(allow_filesystem_tools:) - Convert to Swarm/Workflow
-  # - config.agent_names - Get list of agent names
-  # - config.connections_for(agent_name) - Get delegation targets
-  #
-  # ## Architecture
-  # The facade pattern keeps backward compatibility while separating concerns:
-  # - Parser handles all YAML parsing and validation logic
-  # - Translator handles all DSL builder translation logic
-  # - Configuration delegates to both, exposing parsed data via attr_readers
-  class Configuration
-    attr_reader :config_type,
-      :swarm_name,
-      :swarm_id,
-      :lead_agent,
-      :start_node,
-      :agents,
-      :all_agents_config,
-      :swarm_hooks,
-      :all_agents_hooks,
-      :scratchpad_enabled,
-      :nodes,
-      :external_swarms
-
-    class << self
-      # Load configuration from YAML file
-      #
-      # @param path [String, Pathname] Path to YAML configuration file
-      # @return [Configuration] Validated configuration instance
-      # @raise [ConfigurationError] If file not found or invalid
-      def load_file(path)
-        path = Pathname.new(path).expand_path
-
-        unless path.exist?
-          raise ConfigurationError, "Configuration file not found: #{path}"
-        end
-
-        yaml_content = File.read(path)
-        base_dir = path.dirname
-
-        new(yaml_content, base_dir: base_dir).tap(&:load_and_validate)
-      rescue Errno::ENOENT
-        raise ConfigurationError, "Configuration file not found: #{path}"
-      end
-    end
-
-    # Initialize configuration from YAML string
-    #
-    # @param yaml_content [String] YAML configuration content
-    # @param base_dir [String, Pathname] Base directory for resolving agent file paths (default: Dir.pwd)
-    def initialize(yaml_content, base_dir: Dir.pwd)
-      raise ArgumentError, "yaml_content cannot be nil" if yaml_content.nil?
-      raise ArgumentError, "base_dir cannot be nil" if base_dir.nil?
-
-      @yaml_content = yaml_content
-      @base_dir = Pathname.new(base_dir).expand_path
-      @parser = nil
-      @translator = nil
-    end
-
-    # Parse and validate YAML configuration
-    #
-    # Delegates to Parser for all parsing logic, then syncs parsed data
-    # to instance variables for backward compatibility.
-    #
-    # @return [self]
-    def load_and_validate
-      @parser = Parser.new(@yaml_content, base_dir: @base_dir)
-      @parser.parse
-
-      # Sync parsed data to instance variables for backward compatibility
-      sync_from_parser
-
-      self
-    end
-
-    def agent_names
-      @agents.keys
-    end
-
-    def connections_for(agent_name)
-      agent_config = @agents[agent_name]
-      return [] unless agent_config
-
-      delegates = agent_config[:delegates_to] || []
-      Array(delegates).map(&:to_sym)
-    end
-
-    # Convert configuration to Swarm or Workflow using appropriate builder
-    #
-    # Delegates to Translator for all DSL translation logic.
-    #
-    # @param allow_filesystem_tools [Boolean, nil] Whether to allow filesystem tools (nil uses global setting)
-    # @return [Swarm, Workflow] Configured swarm or workflow
-    def to_swarm(allow_filesystem_tools: nil)
-      raise ConfigurationError, "Configuration not loaded. Call load_and_validate first." unless @parser
-
-      @translator = Translator.new(@parser)
-      @translator.to_swarm(allow_filesystem_tools: allow_filesystem_tools)
-    end
-
-    private
-
-    # Sync parsed data from Parser to instance variables
-    #
-    # This maintains backward compatibility with code that accesses
-    # @config_type, @agents, etc. directly via attr_readers.
-    def sync_from_parser
-      @config_type = @parser.config_type
-      @swarm_name = @parser.swarm_name
-      @swarm_id = @parser.swarm_id
-      @lead_agent = @parser.lead_agent
-      @start_node = @parser.start_node
-      @agents = @parser.agents
-      @all_agents_config = @parser.all_agents_config
-      @swarm_hooks = @parser.swarm_hooks
-      @all_agents_hooks = @parser.all_agents_hooks
-      @external_swarms = @parser.external_swarms
-      @nodes = @parser.nodes
-      @scratchpad_enabled = @parser.scratchpad_mode # NOTE: attr_reader says scratchpad_enabled
-    end
-  end
-end

data/lib/swarm_sdk/context_compactor/metrics.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmSDK
-  class ContextCompactor
-    # Metrics tracks compression statistics
-    #
-    # Provides detailed information about the compression operation:
-    # - Message counts (before/after)
-    # - Token counts (before/after)
-    # - Compression ratio
-    # - Time taken
-    # - Summary of changes
-    #
-    # ## Usage
-    #
-    #   metrics = agent.compact_context
-    #   puts metrics.summary
-    #   puts "Compressed from #{metrics.original_tokens} to #{metrics.compressed_tokens} tokens"
-    #   puts "Compression ratio: #{(metrics.compression_ratio * 100).round(1)}%"
-    #
-    class Metrics
-      attr_reader :original_messages, :compressed_messages, :time_taken
-
-      # Initialize metrics from compression operation
-      #
-      # @param original_messages [Array<RubyLLM::Message>] Messages before compression
-      # @param compressed_messages [Array<RubyLLM::Message>] Messages after compression
-      # @param time_taken [Float] Time taken in seconds
-      def initialize(original_messages:, compressed_messages:, time_taken:)
-        @original_messages = original_messages
-        @compressed_messages = compressed_messages
-        @time_taken = time_taken
-      end
-
-      # Number of messages before compression
-      #
-      # @return [Integer] Original message count
-      def original_message_count
-        @original_messages.size
-      end
-
-      # Number of messages after compression
-      #
-      # @return [Integer] Compressed message count
-      def compressed_message_count
-        @compressed_messages.size
-      end
-
-      # Number of messages removed
-      #
-      # @return [Integer] Messages removed
-      def messages_removed
-        original_message_count - compressed_message_count
-      end
-
-      # Number of checkpoint summary messages created
-      #
-      # @return [Integer] Checkpoint messages
-      def messages_summarized
-        @compressed_messages.count do |msg|
-          msg.role == :system && msg.content.to_s.include?("CONVERSATION CHECKPOINT")
-        end
-      end
-
-      # Estimated tokens before compression
-      #
-      # @return [Integer] Original token count
-      def original_tokens
-        @original_tokens ||= TokenCounter.estimate_messages(@original_messages)
-      end
-
-      # Estimated tokens after compression
-      #
-      # @return [Integer] Compressed token count
-      def compressed_tokens
-        @compressed_tokens ||= TokenCounter.estimate_messages(@compressed_messages)
-      end
-
-      # Number of tokens removed
-      #
-      # @return [Integer] Tokens removed
-      def tokens_removed
-        original_tokens - compressed_tokens
-      end
-
-      # Compression ratio (compressed / original)
-      #
-      # @return [Float] Ratio between 0.0 and 1.0
-      def compression_ratio
-        return 0.0 if original_tokens.zero?
-
-        compressed_tokens.to_f / original_tokens
-      end
-
-      # Compression factor (original / compressed)
-      #
-      # e.g., 5.0 means compressed to 1/5th of original size
-      #
-      # @return [Float] Compression factor
-      def compression_factor
-        return 0.0 if compressed_tokens.zero?
-
-        original_tokens.to_f / compressed_tokens
-      end
-
-      # Compression percentage
-      #
-      # @return [Float] Percentage of original size (0-100)
-      def compression_percentage
-        (compression_ratio * 100).round(2)
-      end
-
-      # Generate a human-readable summary
-      #
-      # @return [String] Summary text
-      def summary
-        <<~SUMMARY
-          Context Compression Results:
-          - Messages: #{original_message_count} → #{compressed_message_count} (-#{messages_removed})
-          - Estimated tokens: #{original_tokens} → #{compressed_tokens} (-#{tokens_removed})
-          - Compression ratio: #{compression_factor.round(1)}:1 (#{compression_percentage}%)
-          - Checkpoints created: #{messages_summarized}
-          - Time taken: #{time_taken.round(3)}s
-        SUMMARY
-      end
-
-      # Convert metrics to hash for logging
-      #
-      # @return [Hash] Metrics as hash
-      def to_h
-        {
-          original_message_count: original_message_count,
-          compressed_message_count: compressed_message_count,
-          messages_removed: messages_removed,
-          messages_summarized: messages_summarized,
-          original_tokens: original_tokens,
-          compressed_tokens: compressed_tokens,
-          tokens_removed: tokens_removed,
-          compression_ratio: compression_ratio.round(4),
-          compression_factor: compression_factor.round(2),
-          compression_percentage: compression_percentage,
-          time_taken: time_taken.round(3),
-        }
-      end
-    end
-  end
-end

data/lib/swarm_sdk/context_compactor/token_counter.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmSDK
-  class ContextCompactor
-    # TokenCounter provides token estimation for messages
-    #
-    # This uses a simple heuristic approach:
-    # - ~4 characters per token for English prose
-    # - ~3.5 characters per token for code
-    #
-    # For production use with OpenAI models, consider using the tiktoken gem
-    # for accurate token counting. For Claude models, use Claude's token API.
-    #
-    # ## Usage
-    #
-    #   tokens = TokenCounter.estimate_message(message)
-    #   total_tokens = TokenCounter.estimate_messages(messages)
-    #
-    class TokenCounter
-      # Backward compatibility aliases - use Defaults module for new code
-      CHARS_PER_TOKEN_PROSE = Defaults::TokenEstimation::CHARS_PER_TOKEN_PROSE
-      CHARS_PER_TOKEN_CODE = Defaults::TokenEstimation::CHARS_PER_TOKEN_CODE
-
-      class << self
-        # Estimate tokens for a single message
-        #
-        # @param message [RubyLLM::Message] Message to estimate
-        # @return [Integer] Estimated token count
-        def estimate_message(message)
-          case message.role
-          when :user, :assistant
-            estimate_content(message.content)
-          when :system
-            estimate_content(message.content)
-          when :tool
-            # Tool results typically have overhead
-            base_overhead = 50
-            content_tokens = estimate_content(message.content)
-            base_overhead + content_tokens
-          else
-            # Unknown message type
-            begin
-              estimate_content(message.content)
-            rescue
-              0
-            end
-          end
-        end
-
-        # Estimate tokens for multiple messages
-        #
-        # @param messages [Array<RubyLLM::Message>] Messages to estimate
-        # @return [Integer] Total estimated token count
-        def estimate_messages(messages)
-          messages.sum { |msg| estimate_message(msg) }
-        end
-
-        # Estimate tokens for content string
-        #
-        # Uses heuristic to detect code vs prose and adjust accordingly.
-        #
-        # @param content [String, RubyLLM::Content, nil] Content to estimate
-        # @return [Integer] Estimated token count
-        def estimate_content(content)
-          return 0 if content.nil?
-
-          # Handle RubyLLM::Content objects
-          text = if content.respond_to?(:to_s)
-            content.to_s
-          else
-            content
-          end
-
-          return 0 if text.empty?
-
-          # Detect if content is mostly code
-          code_ratio = detect_code_ratio(text)
-
-          # Choose characters per token based on content type
-          chars_per_token = if code_ratio > 0.1
-            CHARS_PER_TOKEN_CODE # Code
-          else
-            CHARS_PER_TOKEN_PROSE # Prose
-          end
-
-          (text.length / chars_per_token).ceil
-        end
-
-        private
-
-        # Detect ratio of code characters to total characters
-        #
-        # @param text [String] Text to analyze
-        # @return [Float] Ratio of code indicators (0.0 to 1.0)
-        def detect_code_ratio(text)
-          # Count code indicator characters
-          code_chars = text.scan(/[{}()\[\];]/).length
-
-          return 0.0 if text.empty?
-
-          code_chars.to_f / text.length
-        end
-      end
-    end
-  end
-end