htm 0.0.31 → 0.0.32

data/lib/htm/observability.rb

@@ -93,14 +93,14 @@ class HTM
         # - Pool is healthy if no threads are waiting
         # - Pool is critical only if threads are waiting for connections
         # - size == max_size is normal (pre-allocated pool), not a problem
-        status = if waiting > 0
-          waiting > max_size / 2 ? :exhausted : :critical
-        else
-          :healthy
-        end
+        status = if waiting.positive?
+                   waiting > max_size / 2 ? :exhausted : :critical
+                 else
+                   :healthy
+                 end
 
         # Utilization based on waiting threads (pool stress indicator)
-        utilization = waiting > 0 ? ((waiting.to_f / max_size) * 100).round(2) : 0.0
+        utilization = waiting.positive? ? ((waiting.to_f / max_size) * 100).round(2) : 0.0
 
         stats = {
           size: max_size,
@@ -252,47 +252,11 @@ class HTM
       def health_check
         checks = {}
         issues = []
-
-        # Check database connection
-        checks[:database] = connected?
-        issues << "Database not connected" unless checks[:database]
-
-        # Check connection pool
-        pool_stats = connection_pool_stats
-        checks[:connection_pool] = pool_stats[:status] == :healthy || pool_stats[:status] == :warning
-        issues << "Connection pool #{pool_stats[:status]}" if [:critical, :exhausted].include?(pool_stats[:status])
-
-        # Check circuit breakers
-        cb_stats = circuit_breaker_stats
-        if cb_stats[:embedding_service]
-          checks[:embedding_circuit] = cb_stats[:embedding_service][:state] != :open
-          issues << "Embedding service circuit breaker open" unless checks[:embedding_circuit]
-        end
-        if cb_stats[:tag_service]
-          checks[:tag_circuit] = cb_stats[:tag_service][:state] != :open
-          issues << "Tag service circuit breaker open" unless checks[:tag_circuit]
-        end
-
-        # Check required extensions
-        if connected?
-          begin
-            checks[:pgvector] = extension_installed?('vector')
-            issues << "pgvector extension not installed" unless checks[:pgvector]
-
-            checks[:pg_trgm] = extension_installed?('pg_trgm')
-            issues << "pg_trgm extension not installed" unless checks[:pg_trgm]
-          rescue StandardError => e
-            checks[:extensions] = false
-            issues << "Failed to check extensions: #{e.message}"
-          end
-        end
-
-        {
-          healthy: issues.empty?,
-          checks: checks,
-          issues: issues,
-          checked_at: Time.now
-        }
+        check_database(checks, issues)
+        check_pool(checks, issues)
+        check_circuit_breakers(checks, issues)
+        check_extensions(checks, issues) if connected?
+        { healthy: issues.empty?, checks: checks, issues: issues, checked_at: Time.now }
       end
 
       # Quick health check - returns boolean
@@ -317,6 +281,38 @@ class HTM
 
       private
 
+      def check_database(checks, issues)
+        checks[:database] = connected?
+        issues << "Database not connected" unless checks[:database]
+      end
+
+      def check_pool(checks, issues)
+        pool_stats = connection_pool_stats
+        checks[:connection_pool] = %i[healthy warning].include?(pool_stats[:status])
+        issues << "Connection pool #{pool_stats[:status]}" if %i[critical exhausted].include?(pool_stats[:status])
+      end
+
+      def check_circuit_breakers(checks, issues)
+        cb_stats = circuit_breaker_stats
+        if cb_stats[:embedding_service]
+          checks[:embedding_circuit] = cb_stats[:embedding_service][:state] != :open
+          issues << "Embedding service circuit breaker open" unless checks[:embedding_circuit]
+        end
+        return unless cb_stats[:tag_service]
+        checks[:tag_circuit] = cb_stats[:tag_service][:state] != :open
+        issues << "Tag service circuit breaker open" unless checks[:tag_circuit]
+      end
+
+      def check_extensions(checks, issues)
+        checks[:pgvector] = extension_installed?('vector')
+        issues << "pgvector extension not installed" unless checks[:pgvector]
+        checks[:pg_trgm] = extension_installed?('pg_trgm')
+        issues << "pg_trgm extension not installed" unless checks[:pg_trgm]
+      rescue StandardError => e
+        checks[:extensions] = false
+        issues << "Failed to check extensions: #{e.message}"
+      end
+
       # Check if Sequel database is connected
       def connected?
         return false unless defined?(HTM) && HTM.respond_to?(:db)
@@ -332,7 +328,7 @@ class HTM
         result = HTM.db.fetch(
           "SELECT COUNT(*) AS cnt FROM pg_extension WHERE extname = ?", name
         ).first
-        result[:cnt].to_i > 0
+        result[:cnt].to_i.positive?
       end
 
       # Calculate timing statistics from samples
@@ -365,7 +361,7 @@ class HTM
 
         return sorted_array[f] if f == c
 
-        sorted_array[f] * (c - k) + sorted_array[c] * (k - f)
+        (sorted_array[f] * (c - k)) + (sorted_array[c] * (k - f))
       end
 
       # Get process memory in MB
@@ -376,8 +372,6 @@ class HTM
         elsif File.exist?('/proc/self/status')
           # Linux: Read from proc
           File.read('/proc/self/status').match(/VmRSS:\s+(\d+)/)[1].to_i / 1024.0
-        else
-          nil
         end
       rescue StandardError
         nil

data/lib/htm/proposition_service.rb

@@ -89,11 +89,7 @@ class HTM
 
       # Validate and filter propositions
       validate_and_filter_propositions(parsed_propositions)
-
-    rescue HTM::CircuitBreakerOpenError
-      # Re-raise circuit breaker errors without wrapping
-      raise
-    rescue HTM::PropositionError
+    rescue HTM::CircuitBreakerOpenError, HTM::PropositionError
       raise
     rescue StandardError => e
       HTM.logger.error "PropositionService: Failed to extract propositions: #{e.message}"
@@ -149,9 +145,9 @@ class HTM
     # @return [Integer] Minimum word count for valid propositions
     #
     def self.min_words
-      HTM.config.proposition.min_words || 5
+      HTM.config.proposition.min_words || 3
     rescue
-      5
+      3
     end
 
     # Check if proposition is a meta-response (LLM asking for input)

data/lib/htm/query_cache.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'lru_redux'
-require 'set'
 
 class HTM
   # Thread-safe query result cache with TTL and statistics
@@ -31,7 +30,7 @@ class HTM
     attr_reader :enabled
 
     # Cache key prefix for method-based invalidation
-    METHOD_PREFIX = "m:".freeze
+    METHOD_PREFIX = "m:"
 
     # Initialize a new query cache
     #
@@ -39,16 +38,15 @@ class HTM
     # @param ttl [Integer] Time-to-live in seconds (default: 300)
     #
     def initialize(size: 1000, ttl: 300)
-      @enabled = size > 0
-
-      if @enabled
-        @cache = LruRedux::TTL::ThreadSafeCache.new(size, ttl)
-        @hits = 0
-        @misses = 0
-        @mutex = Mutex.new
-        # Track keys by method for selective invalidation
-        @keys_by_method = Hash.new { |h, k| h[k] = Set.new }
-      end
+      @enabled = size.positive?
+
+      return unless @enabled
+      @cache = LruRedux::TTL::ThreadSafeCache.new(size, ttl)
+      @hits = 0
+      @misses = 0
+      @mutex = Mutex.new
+      # Track keys by method for selective invalidation
+      @keys_by_method = Hash.new { |h, k| h[k] = Set.new }
     end
 
     # Fetch a value from cache or execute block
@@ -58,10 +56,10 @@ class HTM
     # @yield Block that computes the value if not cached
     # @return [Object] Cached or computed value
     #
-    def fetch(method, *args, &block)
+    def fetch(method, *, &)
       return yield unless @enabled
 
-      key = cache_key(method, *args)
+      key = cache_key(method, *)
 
       if (cached = @cache[key])
         @mutex.synchronize { @hits += 1 }
@@ -131,7 +129,7 @@ class HTM
       return nil unless @enabled
 
       total = @hits + @misses
-      hit_rate = total > 0 ? (@hits.to_f / total * 100).round(2) : 0.0
+      hit_rate = total.positive? ? (@hits.to_f / total * 100).round(2) : 0.0
 
       {
         hits: @hits,

data/lib/htm/railtie.rb

@@ -26,7 +26,7 @@ class HTM
     railtie_name :htm
 
     # Configure HTM before Rails initializers run
-    initializer "htm.configure" do |app|
+    initializer "htm.configure" do |_app|
       HTM.configure do |config|
         # Use Rails logger
         config.logger = Rails.logger
@@ -66,6 +66,5 @@ class HTM
         end
       end
     end
-
   end
 end

data/lib/htm/robot_group.rb

@@ -320,7 +320,7 @@ class HTM
     #     originator: 'agent-2'
     #   )
     #
-    def remember(content, originator: nil, **options)
+    def remember(content, originator: nil, **)
       raise 'No active robots in group' if @active_robots.empty?
 
       # Use first active robot (or specified originator) to create the memory
@@ -330,7 +330,7 @@ class HTM
                   @active_robots.values.first
                 end
 
-      node_id = primary.remember(content, **options)
+      node_id = primary.remember(content, **)
 
       # Sync to database (robot_nodes table) for all other members
       sync_node_to_members(node_id, exclude: primary.robot_id)
@@ -356,11 +356,11 @@ class HTM
     # @example
     #   results = group.recall('billing issue', limit: 5, strategy: :fulltext)
     #
-    def recall(query, **options)
+    def recall(query, **)
       raise 'No active robots in group' if @active_robots.empty?
 
       primary = @active_robots.values.first
-      primary.recall(query, **options)
+      primary.recall(query, **)
     end
 
     # Returns all nodes currently in shared working memory.
@@ -476,7 +476,7 @@ class HTM
 
       all_robots.each_key do |robot_name|
         synced = sync_robot(robot_name)
-        if synced > 0
+        if synced.positive?
           members_updated += 1
           total_synced    += synced
         end
@@ -634,7 +634,7 @@ class HTM
         working_memory_nodes: wm_contents.count,
         working_memory_tokens: token_count,
         max_tokens: @max_tokens,
-        token_utilization: @max_tokens > 0 ? (token_count.to_f / @max_tokens).round(2) : 0,
+        token_utilization: @max_tokens.positive? ? (token_count.to_f / @max_tokens).round(2) : 0,
         in_sync: in_sync?
       }
     end
@@ -685,7 +685,7 @@ class HTM
       node = HTM::Models::Node.first(id: node_id)
       return unless node
 
-      all_robots.each do |_name, htm|
+      all_robots.each_value do |htm|
         next if htm.robot_id == origin_robot_id
 
         htm.working_memory.add_from_sync(
@@ -698,7 +698,7 @@ class HTM
     end
 
     def evict_from_in_memory_caches(node_id, origin_robot_id)
-      all_robots.each do |_name, htm|
+      all_robots.each_value do |htm|
         next if htm.robot_id == origin_robot_id
 
         htm.working_memory.remove_from_sync(node_id)
@@ -706,7 +706,7 @@ class HTM
     end
 
     def clear_all_in_memory_caches(origin_robot_id)
-      all_robots.each do |_name, htm|
+      all_robots.each_value do |htm|
         next if htm.robot_id == origin_robot_id
 
         htm.working_memory.clear_from_sync

data/lib/htm/sequel_config.rb

@@ -198,6 +198,7 @@ class HTM
         require_relative 'models/robot_node'
         require_relative 'models/tag'
         require_relative 'models/node_tag'
+        require_relative 'models/node_relationship'
         require_relative 'models/file_source'
 
         @models_loaded = true

data/lib/htm/sql_builder.rb

@@ -63,7 +63,7 @@ class HTM
           raise ArgumentError, "Embedding contains invalid values at #{sample}"
         end
 
-        "[#{embedding.map { |v| v.to_f }.join(',')}]"
+        "[#{embedding.map(&:to_f).join(',')}]"
       end
 
       # Pad embedding to target dimension

data/lib/htm/tag_service.rb

@@ -16,7 +16,7 @@ class HTM
   # The actual LLM call is delegated to HTM.configuration.tag_extractor
   #
   class TagService
-    TAG_FORMAT = /^[a-z0-9\-]+(:[a-z0-9\-]+)*$/  # Validation regex
+    TAG_FORMAT = /^[a-z0-9-]+(:[a-z0-9-]+)*$/  # Validation regex
 
     # Circuit breaker for tag extraction API calls
     @circuit_breaker = nil
@@ -76,11 +76,7 @@ class HTM
 
       # Validate and filter tags
       validate_and_filter_tags(parsed_tags)
-
-    rescue HTM::CircuitBreakerOpenError
-      # Re-raise circuit breaker errors without wrapping
-      raise
-    rescue HTM::TagError
+    rescue HTM::CircuitBreakerOpenError, HTM::TagError
       raise
     rescue StandardError => e
       HTM.logger.error "TagService: Failed to extract tags: #{e.message}"

data/lib/htm/timeframe.rb

@@ -61,7 +61,7 @@ class HTM
 
         else
           raise ArgumentError, "Unsupported timeframe type: #{input.class}. " \
-            "Expected nil, Range, Array<Range>, Date, DateTime, Time, String, or :auto"
+                               "Expected nil, Range, Array<Range>, Date, DateTime, Time, String, or :auto"
         end
       end
 
@@ -75,7 +75,7 @@ class HTM
         when nil, :auto, Range, Date, DateTime, Time, String
           true
         when Array
-          input.all? { |r| r.is_a?(Range) }
+          input.all?(Range)
         else
           false
         end
@@ -185,9 +185,8 @@ class HTM
       # @raise [ArgumentError] If range is invalid
       #
       def validate_range!(range)
-        unless range.begin.respond_to?(:to_time) && range.end.respond_to?(:to_time)
-          raise ArgumentError, "Range must have Time-compatible begin and end values"
-        end
+        return if range.begin.respond_to?(:to_time) && range.end.respond_to?(:to_time)
+        raise ArgumentError, "Range must have Time-compatible begin and end values"
       end
     end
   end

data/lib/htm/timeframe_extractor.rb

@@ -44,6 +44,17 @@ class HTM
       'six' => 6, 'seven' => 7, 'eight' => 8, 'nine' => 9, 'ten' => 10
     }.freeze
 
+    # Seconds per singular time unit (used by parse_last_x and parse_recent)
+    UNIT_SECONDS = {
+      'second' => 1,
+      'minute' => 60,
+      'hour'   => 3_600,
+      'day'    => 86_400,
+      'week'   => 604_800,
+      'month'  => 2_592_000,
+      'year'   => 31_536_000
+    }.freeze
+
     # Patterns for temporal expressions (order matters - more specific first)
     # Each pattern should match ORIGINAL text (including "few", "a few")
     TEMPORAL_PATTERNS = [
@@ -84,7 +95,7 @@ class HTM
       /\b(?:recently|recent)\b/i,
 
       # Standard time words
-      /\b(?:yesterday|today|tonight|this\s+morning|this\s+afternoon|this\s+evening|last\s+night)\b/i,
+      /\b(?:yesterday|today|tonight|this\s+morning|this\s+afternoon|this\s+evening|last\s+night)\b/i
     ].freeze
 
     # Result structure for extracted timeframe
@@ -153,49 +164,21 @@ class HTM
       # @return [Time, Range, nil] Parsed timeframe
       #
       def parse_expression(expression)
-        # Handle "recently/recent" specially - default to FEW days
-        if expression.match?(/\b(?:recently|recent)\b/i)
-          return parse_recent
-        end
-
-        # Handle "weekend before last" - 2 weekends ago
-        if expression.match?(/\bweekend\s+before\s+last\b/i)
-          return parse_weekends_ago(2)
-        end
+        return parse_recent if expression.match?(/\b(?:recently|recent)\b/i)
+        return parse_weekends_ago(2) if expression.match?(/\bweekend\s+before\s+last\b/i)
 
-        # Handle "N weekends ago" (numeric or written)
-        if match = expression.match(/\b(\d+|one|two|three|four|five|six|seven|eight|nine|ten|few|a\s+few|several)\s+weekends?\s+ago\b/i)
-          count = parse_number(match[1])
-          return parse_weekends_ago(count)
+        if (match = expression.match(/\b(\d+|one|two|three|four|five|six|seven|eight|nine|ten|few|a\s+few|several)\s+weekends?\s+ago\b/i))
+          return parse_weekends_ago(parse_number(match[1]))
         end
 
-        # Normalize "few" to numeric value for Chronic
-        normalized = normalize_few_keywords(expression)
+        normalized    = normalize_few_keywords(expression)
+        chronic_expr  = normalized.gsub(/\bin\s+the\s+/i, '')
 
-        # Handle "in the last/past X units" - create range from X ago to now
-        if match = normalized.match(/(?:in\s+the\s+)?(?:last|past)\s+(\d+)\s+(#{TIME_UNITS})/i)
+        if (match = normalized.match(/(?:in\s+the\s+)?(?:last|past)\s+(\d+)\s+(#{TIME_UNITS})/i))
           return parse_last_x(match[1].to_i, match[2])
         end
 
-        # Strip "in the" prefix for Chronic
-        chronic_expr = normalized.gsub(/\bin\s+the\s+/i, '')
-
-        # Get week_start from HTM configuration (default: :sunday)
-        week_start = :sunday
-        if defined?(HTM) && HTM.respond_to?(:configuration)
-          week_start = HTM.configuration.week_start
-        end
-
-        # Try to get a span/range first
-        result = Chronic.parse(chronic_expr, guess: false, week_start: week_start)
-
-        # Convert Chronic::Span to Range if needed
-        if result.respond_to?(:begin) && result.respond_to?(:end)
-          return result.begin..result.end
-        end
-
-        # Fall back to point in time
-        Chronic.parse(chronic_expr, week_start: week_start)
+        chronic_parse_expression(chronic_expr)
       end
 
       # Parse a number from string (numeric or written word)
@@ -205,7 +188,7 @@ class HTM
       #
       def parse_number(str)
         normalized = str.downcase.strip
-        return FEW if normalized == 'few' || normalized == 'a few' || normalized == 'several'
+        return FEW if ['few', 'a few', 'several'].include?(normalized)
         return WORD_NUMBERS[normalized] if WORD_NUMBERS.key?(normalized)
         normalized.to_i
       end
@@ -217,23 +200,26 @@ class HTM
       #
       def parse_weekends_ago(count)
         now = Time.now
+        target_saturday = last_saturday_before(now) - ((count - 1) * 7 * 86_400)
+        target_saturday..(target_saturday + (2 * 86_400))
+      end
 
-        # Find last Saturday (most recent Saturday before or equal to today)
-        days_since_saturday = (now.wday - 6) % 7
-        days_since_saturday = 7 if days_since_saturday == 0 && now.wday != 6  # If today is Sunday, last Saturday was yesterday
-
-        last_saturday = Time.new(now.year, now.month, now.day, 0, 0, 0) - (days_since_saturday * 24 * 60 * 60)
-
-        # Go back (count - 1) more weeks to get to the target weekend
-        # count=1 means "last weekend" = the most recent past weekend
-        # count=2 means "weekend before last" = 2 weekends ago
-        target_saturday = last_saturday - ((count - 1) * 7 * 24 * 60 * 60)
+      def chronic_parse_expression(expr)
+        week_start = fetch_week_start
+        result     = Chronic.parse(expr, guess: false, week_start: week_start)
+        return result.begin..result.end if result.respond_to?(:begin) && result.respond_to?(:end)
+        Chronic.parse(expr, week_start: week_start)
+      end
 
-        # Weekend spans Saturday 00:00 to Monday 00:00
-        weekend_start = target_saturday
-        weekend_end = target_saturday + (2 * 24 * 60 * 60)  # Monday 00:00
+      def fetch_week_start
+        return HTM.configuration.week_start if defined?(HTM) && HTM.respond_to?(:configuration)
+        :sunday
+      end
 
-        weekend_start..weekend_end
+      def last_saturday_before(now)
+        days_since = (now.wday - 6) % 7
+        days_since = 7 if days_since.zero? && now.wday != 6
+        Time.new(now.year, now.month, now.day, 0, 0, 0) - (days_since * 86_400)
       end
 
       # Parse "last X units" or "past X units" to a proper range
@@ -244,19 +230,8 @@ class HTM
       #
       def parse_last_x(count, unit)
         now = Time.now
-        unit_normalized = unit.downcase.sub(/s$/, '')  # Remove trailing 's'
-
-        seconds = case unit_normalized
-        when 'second' then count
-        when 'minute' then count * 60
-        when 'hour' then count * 60 * 60
-        when 'day' then count * 24 * 60 * 60
-        when 'week' then count * 7 * 24 * 60 * 60
-        when 'month' then count * 30 * 24 * 60 * 60
-        when 'year' then count * 365 * 24 * 60 * 60
-        else count * 24 * 60 * 60  # Default to days
-        end
-
+        unit_singular = unit.downcase.sub(/s$/, '')
+        seconds = count * (UNIT_SECONDS[unit_singular] || UNIT_SECONDS['day'])
         (now - seconds)..now
       end
 
@@ -266,24 +241,8 @@ class HTM
       #
       def parse_recent
         now = Time.now
-        case DEFAULT_RECENT_UNIT
-        when :seconds
-          (now - FEW)..now
-        when :minutes
-          (now - (FEW * 60))..now
-        when :hours
-          (now - (FEW * 60 * 60))..now
-        when :days
-          (now - (FEW * 24 * 60 * 60))..now
-        when :weeks
-          (now - (FEW * 7 * 24 * 60 * 60))..now
-        when :months
-          (now - (FEW * 30 * 24 * 60 * 60))..now
-        when :years
-          (now - (FEW * 365 * 24 * 60 * 60))..now
-        else
-          (now - (FEW * 24 * 60 * 60))..now
-        end
+        seconds = FEW * (UNIT_SECONDS[DEFAULT_RECENT_UNIT.to_s] || UNIT_SECONDS['day'])
+        (now - seconds)..now
       end
 
       # Clean the query by removing the temporal expression

data/lib/htm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class HTM
-  VERSION = '0.0.31'
+  VERSION = '0.0.32'
 end