Class: Legion::Extensions::Agentic::Learning::Chrysalis::Helpers::MetamorphosisEngine

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

Instance Method Summary collapse

Constructor Details

#initialize ⇒ MetamorphosisEngine

Returns a new instance of MetamorphosisEngine.



10
11
12
13
14
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 10

def initialize
  @chrysalises = {}
  @cocoons     = {}
  @sheltered   = {} # chrysalis_id => cocoon_id
end

Instance Method Details

#butterflies ⇒ Object 



119
120
121
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 119

def butterflies
  @chrysalises.values.select(&:butterfly?)
end

#create_chrysalis(chrysalis_type:, content:) ⇒ Object 



16
17
18
19
20
21
22
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 16

def create_chrysalis(chrysalis_type:, content:, **)
  return { success: false, reason: :capacity_exceeded } if @chrysalises.size >= Helpers::Constants::MAX_CHRYSALISES

  c = Chrysalis.new(chrysalis_type: chrysalis_type, content: content)
  @chrysalises[c.id] = c
  { success: true, chrysalis: c.to_h }
end

#create_cocoon(environment:) ⇒ Object 



24
25
26
27
28
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 24

def create_cocoon(environment:, **)
  cocoon = Cocoon.new(environment: environment)
  @cocoons[cocoon.id] = cocoon
  { success: true, cocoon: cocoon.to_h }
end

#disturb_cocoon(cocoon_id:, force:) ⇒ Object 



88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 88

def disturb_cocoon(cocoon_id:, force:, **)
  cocoon = @cocoons.fetch(cocoon_id, nil)
  return { success: false, reason: :not_found } unless cocoon

  disturbed = []
  cocoon.chrysalis_ids.each do |cid|
    c = @chrysalises[cid]
    next unless c

    c.disturb!(force.to_f)
    disturbed << { chrysalis_id: cid, protection: c.protection, stage: c.stage }
  end
  { success: true, disturbed: disturbed, force: force }
end

#enclose(chrysalis_id:, cocoon_id:) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 40

def enclose(chrysalis_id:, cocoon_id:, **)
  c      = @chrysalises.fetch(chrysalis_id, nil)
  cocoon = @cocoons.fetch(cocoon_id, nil)
  return { success: false, reason: :chrysalis_not_found } unless c
  return { success: false, reason: :cocoon_not_found }    unless cocoon

  c.spin! if c.stage == :larva
  c.cocoon! if c.stage == :spinning
  cocoon.shelter(chrysalis_id)
  @sheltered[chrysalis_id] = cocoon_id
  { success: true, stage: c.stage, cocoon_id: cocoon_id }
rescue ArgumentError => e
  { success: false, reason: e.message }
end

#force_emerge(chrysalis_id:) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 70

def force_emerge(chrysalis_id:, **)
  c = @chrysalises.fetch(chrysalis_id, nil)
  return { success: false, reason: :not_found } unless c

  c.emerge!(force: true)
  { success: true, stage: c.stage, beauty: c.beauty, premature: c.premature? }
end

#incubate(chrysalis_id:) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 55

def incubate(chrysalis_id:, **)
  c = @chrysalises.fetch(chrysalis_id, nil)
  return { success: false, reason: :not_found } unless c
  return { success: false, reason: :already_butterfly } if c.butterfly?

  rate = Helpers::Constants::TRANSFORMATION_RATE
  if (cid = @sheltered[chrysalis_id])
    cocoon = @cocoons[cid]
    rate  += cocoon.growth_modifier if cocoon
  end

  c.transform!(rate)
  { success: true, progress: c.transformation_progress, stage: c.stage }
end

#incubate_all! ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 103

def incubate_all!(**)
  results = []
  @chrysalises.each_value do |c|
    next unless %i[cocooned transforming].include?(c.stage)

    rate = Helpers::Constants::TRANSFORMATION_RATE
    if (cid = @sheltered[c.id])
      cocoon = @cocoons[cid]
      rate  += cocoon.growth_modifier if cocoon
    end
    c.transform!(rate)
    results << { chrysalis_id: c.id, progress: c.transformation_progress, stage: c.stage }
  end
  { success: true, incubated: results.size, results: results }
end

#metamorphosis_report ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 123

def metamorphosis_report(**)
  all = @chrysalises.values
  butterfly_list = all.select(&:butterfly?)
  {
    total_chrysalises:  all.size,
    total_cocoons:      @cocoons.size,
    butterflies_count:  butterfly_list.size,
    premature_count:    butterfly_list.count(&:premature?),
    avg_beauty:         avg_beauty(butterfly_list),
    avg_progress:       avg_progress(all),
    cocooned_count:     all.count(&:cocooned?),
    transforming_count: all.count(&:transforming?)
  }
end

#natural_emerge(chrysalis_id:) ⇒ Object 



78
79
80
81
82
83
84
85
86
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 78

def natural_emerge(chrysalis_id:, **)
  c = @chrysalises.fetch(chrysalis_id, nil)
  return { success: false, reason: :not_found } unless c

  result = c.emerge!
  return { success: false, reason: :not_ready, progress: c.transformation_progress } unless result

  { success: true, stage: c.stage, beauty: c.beauty, premature: c.premature? }
end

#spin(chrysalis_id:) ⇒ Object 



30
31
32
33
34
35
36
37
38
 
# File 'lib/legion/extensions/agentic/learning/chrysalis/helpers/metamorphosis_engine.rb', line 30

def spin(chrysalis_id:, **)
  c = @chrysalises.fetch(chrysalis_id, nil)
  return { success: false, reason: :not_found } unless c

  c.spin!
  { success: true, stage: c.stage }
rescue ArgumentError => e
  { success: false, reason: e.message }
end