Class: Legion::Extensions::Agentic::Learning::Curiosity::Helpers::WonderStore

Inherits:
Object
  • Object
show all
Defined in:
lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb

Overview

In-memory priority queue for wonder items with domain balancing and decay.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ WonderStore

Returns a new instance of WonderStore.



13
14
15
16
17
18
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 13

def initialize
  @wonders = {}
  @resolved_count = 0
  @total_generated = 0
  @domain_resolution_rates = Hash.new { |h, k| h[k] = { resolved: 0, total: 0 } }
end

Instance Attribute Details

#resolved_count ⇒ Object (readonly)

Returns the value of attribute resolved_count.



11
12
13
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 11

def resolved_count
  @resolved_count
end

#total_generated ⇒ Object (readonly)

Returns the value of attribute total_generated.



11
12
13
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 11

def total_generated
  @total_generated
end

Instance Method Details

#active_count ⇒ Object 



109
110
111
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 109

def active_count
  active_wonders.size
end

#active_wonders ⇒ Object 



43
44
45
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 43

def active_wonders
  @wonders.values.reject { |w| w[:resolved] }
end

#by_domain(domain) ⇒ Object 



71
72
73
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 71

def by_domain(domain)
  active_wonders.select { |w| w[:domain] == domain.to_sym }
end

#count ⇒ Object 



105
106
107
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 105

def count
  @wonders.size
end

#decay_all(hours_elapsed: 1.0) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 89

def decay_all(hours_elapsed: 1.0)
  pruned = 0
  @wonders.each do |id, wonder|
    next if wonder[:resolved]

    decayed = Wonder.decay_salience(wonder, hours_elapsed: hours_elapsed)
    if decayed[:salience] <= 0.0 || Wonder.stale?(decayed)
      @wonders.delete(id)
      pruned += 1
    else
      @wonders[id] = decayed
    end
  end
  pruned
end

#delete(wonder_id) ⇒ Object 



39
40
41
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 39

def delete(wonder_id)
  @wonders.delete(wonder_id)
end

#domain_resolution_rate(domain) ⇒ Object 



128
129
130
131
132
133
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 128

def domain_resolution_rate(domain)
  rates = @domain_resolution_rates[domain.to_sym]
  return 0.0 if rates[:total].zero?

  rates[:resolved].to_f / rates[:total]
end

#domain_stats ⇒ Object 



113
114
115
116
117
118
119
120
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 113

def domain_stats
  stats = Hash.new { |h, k| h[k] = { active: 0, resolved: 0 } }
  @wonders.each_value do |w|
    key = w[:resolved] ? :resolved : :active
    stats[w[:domain]][key] += 1
  end
  stats
end

#get(wonder_id) ⇒ Object 



28
29
30
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 28

def get(wonder_id)
  @wonders[wonder_id]
end

#mark_resolved(wonder_id, resolution:, actual_gain: 0.5) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 75

def mark_resolved(wonder_id, resolution:, actual_gain: 0.5)
  wonder = @wonders[wonder_id]
  return nil unless wonder

  @wonders[wonder_id] = wonder.merge(
    resolved:    true,
    resolution:  resolution,
    actual_gain: actual_gain
  )
  @resolved_count += 1
  @domain_resolution_rates[wonder[:domain]][:resolved] += 1
  @wonders[wonder_id]
end

#resolution_rate ⇒ Object 



122
123
124
125
126
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 122

def resolution_rate
  return 0.0 if @total_generated.zero?

  @resolved_count.to_f / @total_generated
end

#resolved_wonders ⇒ Object 



47
48
49
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 47

def resolved_wonders
  @wonders.values.select { |w| w[:resolved] }
end

#store(wonder) ⇒ Object 



20
21
22
23
24
25
26
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 20

def store(wonder)
  prune_if_full
  @wonders[wonder[:wonder_id]] = wonder
  @total_generated += 1
  @domain_resolution_rates[wonder[:domain]][:total] += 1
  wonder
end

#top(limit: 5, exclude_domains: []) ⇒ Object 



51
52
53
54
55
56
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 51

def top(limit: 5, exclude_domains: [])
  active_wonders
    .reject { |w| exclude_domains.include?(w[:domain]) }
    .sort_by { |w| -Wonder.score(w) }
    .first(limit)
end

#top_balanced(limit: 5) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 58

def top_balanced(limit: 5)
  domain_counts = active_wonders.group_by { |w| w[:domain] }
                                .transform_values(&:size)
  max_domain = domain_counts.values.max || 1

  active_wonders
    .sort_by do |w|
      domain_penalty = (domain_counts[w[:domain]].to_f / max_domain) * Constants::DOMAIN_BALANCE_FACTOR
      -(Wonder.score(w) - domain_penalty)
    end
    .first(limit)
end

#update(wonder_id, attrs) ⇒ Object 



32
33
34
35
36
37
 
# File 'lib/legion/extensions/agentic/learning/curiosity/helpers/wonder_store.rb', line 32

def update(wonder_id, attrs)
  wonder = @wonders[wonder_id]
  return nil unless wonder

  @wonders[wonder_id] = wonder.merge(attrs)
end